libv8 6.7.288.46.1 → 7.3.492.27.0beta1

data/vendor/depot_tools/owners_finder.py

@@ -26,7 +26,8 @@ class OwnersFinder(object):
                fopen, os_path,
                email_postfix='@chromium.org',
                disable_color=False,
-               override_files=None):
+               override_files=None,
+               ignore_author=False):
     self.email_postfix = email_postfix
 
     if os.name == 'nt' or disable_color:
@@ -46,7 +47,7 @@ class OwnersFinder(object):
     filtered_files = files
 
     reviewers = list(reviewers)
-    if author:
+    if author and not ignore_author:
       reviewers.append(author)
 
     # Eliminate files that existing reviewers can review.
@@ -62,6 +63,8 @@ class OwnersFinder(object):
       self.db.load_data_needed_for(files)
 
     self.all_possible_owners = self.db.all_possible_owners(files, None)
+    if author and author in self.all_possible_owners:
+      del self.all_possible_owners[author]
 
     self.owners_to_files = {}
     self._map_owners_to_files(files)

data/vendor/depot_tools/presubmit_canned_checks.py

@@ -248,15 +248,38 @@ def _ReportErrorFileAndLine(filename, line_num, dummy_line):
   return '%s:%s' % (filename, line_num)
 
 
-def _FindNewViolationsOfRule(callable_rule, input_api, source_file_filter=None,
-                             error_formatter=_ReportErrorFileAndLine):
+def _GenerateAffectedFileExtList(input_api, source_file_filter):
+  """Generate a list of (file, extension) tuples from affected files.
+
+  The result can be fed to _FindNewViolationsOfRule() directly, or
+  could be filtered before doing that.
+
+  Args:
+    input_api: object to enumerate the affected files.
+    source_file_filter: a filter to be passed to the input api.
+  Yields:
+    A list of (file, extension) tuples, where |file| is an affected
+      file, and |extension| its file path extension.
+  """
+  for f in input_api.AffectedFiles(
+      include_deletes=False, file_filter=source_file_filter):
+    extension = str(f.LocalPath()).rsplit('.', 1)[-1]
+    yield (f, extension)
+
+
+def _FindNewViolationsOfRuleForList(callable_rule,
+                                    file_ext_list,
+                                    error_formatter=_ReportErrorFileAndLine):
   """Find all newly introduced violations of a per-line rule (a callable).
 
+  Prefer calling _FindNewViolationsOfRule() instead of this function, unless
+  the list of affected files need to be filtered in a special way.
+
   Arguments:
     callable_rule: a callable taking a file extension and line of input and
       returning True if the rule is satisfied and False if there was a problem.
-    input_api: object to enumerate the affected files.
-    source_file_filter: a filter to be passed to the input api.
+    file_ext_list: a list of input (file, extension) tuples, as returned by
+      _GenerateAffectedFileExtList().
     error_formatter: a callable taking (filename, line_number, line) and
       returning a formatted error string.
 
@@ -264,13 +287,11 @@ def _FindNewViolationsOfRule(callable_rule, input_api, source_file_filter=None,
     A list of the newly-introduced violations reported by the rule.
   """
   errors = []
-  for f in input_api.AffectedFiles(include_deletes=False,
-                                   file_filter=source_file_filter):
+  for f, extension in file_ext_list:
     # For speed, we do two passes, checking first the full file.  Shelling out
     # to the SCM to determine the changed region can be quite expensive on
     # Win32.  Assuming that most files will be kept problem-free, we can
     # skip the SCM operations most of the time.
-    extension = str(f.LocalPath()).rsplit('.', 1)[-1]
     if all(callable_rule(extension, line) for line in f.NewContents()):
       continue  # No violation found in full text: can skip considering diff.
 
@@ -281,6 +302,28 @@ def _FindNewViolationsOfRule(callable_rule, input_api, source_file_filter=None,
   return errors
 
 
+def _FindNewViolationsOfRule(callable_rule,
+                             input_api,
+                             source_file_filter=None,
+                             error_formatter=_ReportErrorFileAndLine):
+  """Find all newly introduced violations of a per-line rule (a callable).
+
+  Arguments:
+    callable_rule: a callable taking a file extension and line of input and
+      returning True if the rule is satisfied and False if there was a problem.
+    input_api: object to enumerate the affected files.
+    source_file_filter: a filter to be passed to the input api.
+    error_formatter: a callable taking (filename, line_number, line) and
+      returning a formatted error string.
+
+  Returns:
+    A list of the newly-introduced violations reported by the rule.
+  """
+  return _FindNewViolationsOfRuleForList(
+      callable_rule, _GenerateAffectedFileExtList(
+          input_api, source_file_filter), error_formatter)
+
+
 def CheckChangeHasNoTabs(input_api, output_api, source_file_filter=None):
   """Checks that there are no tab characters in any of the text files to be
   submitted.
@@ -385,11 +428,6 @@ def CheckLongLines(input_api, output_api, maxlen, source_file_filter=None):
     if any((url in line) for url in ('file://', 'http://', 'https://')):
       return True
 
-    # If 'line-too-long' is explicitly suppressed for the line, any length is
-    # acceptable.
-    if 'pylint: disable=line-too-long' in line and file_extension == 'py':
-      return True
-
     if line_len > extra_maxlen:
       return False
 
@@ -402,12 +440,64 @@ def CheckLongLines(input_api, output_api, maxlen, source_file_filter=None):
     return input_api.re.match(
         r'.*[A-Za-z][A-Za-z_0-9]{%d,}.*' % long_symbol, line)
 
+  def is_global_pylint_directive(line, pos):
+    """True iff the pylint directive starting at line[pos] is global."""
+    # Any character before |pos| that is not whitespace or '#' indidcates
+    # this is a local directive.
+    return not any([c not in " \t#" for c in line[:pos]])
+
+  def check_python_long_lines(affected_files, error_formatter):
+    errors = []
+    global_check_enabled = True
+
+    for f in affected_files:
+      file_path = f.LocalPath()
+      for idx, line in enumerate(f.NewContents()):
+        line_num = idx + 1
+        line_is_short = no_long_lines(PY_FILE_EXTS[0], line)
+
+        pos = line.find('pylint: disable=line-too-long')
+        if pos >= 0:
+          if is_global_pylint_directive(line, pos):
+            global_check_enabled = False  # Global disable
+          else:
+            continue  # Local disable.
+
+        do_check = global_check_enabled
+
+        pos = line.find('pylint: enable=line-too-long')
+        if pos >= 0:
+          if is_global_pylint_directive(line, pos):
+            global_check_enabled = True  # Global enable
+            do_check = True  # Ensure it applies to current line as well.
+          else:
+            do_check = True  # Local enable
+
+        if do_check and not line_is_short:
+          errors.append(error_formatter(file_path, line_num, line))
+
+    return errors
+
   def format_error(filename, line_num, line):
     return '%s, line %s, %s chars' % (filename, line_num, len(line))
 
-  errors = _FindNewViolationsOfRule(no_long_lines, input_api,
-                                    source_file_filter,
-                                    error_formatter=format_error)
+  file_ext_list = list(
+      _GenerateAffectedFileExtList(input_api, source_file_filter))
+
+  errors = []
+
+  # For non-Python files, a simple line-based rule check is enough.
+  non_py_file_ext_list = [x for x in file_ext_list if x[1] not in PY_FILE_EXTS]
+  if non_py_file_ext_list:
+    errors += _FindNewViolationsOfRuleForList(
+        no_long_lines, non_py_file_ext_list, error_formatter=format_error)
+
+  # However, Python files need more sophisticated checks that need parsing
+  # the whole source file.
+  py_file_list = [x[0] for x in file_ext_list if x[1] in PY_FILE_EXTS]
+  if py_file_list:
+    errors += check_python_long_lines(
+        py_file_list, error_formatter=format_error)
   if errors:
     msg = 'Found lines longer than %s characters (first 5 shown).' % maxlen
     return [output_api.PresubmitPromptWarning(msg, items=errors[:5])]
@@ -840,7 +930,9 @@ def CheckOwnersFormat(input_api, output_api):
   if not affected_files:
     return []
   try:
-    input_api.owners_db.load_data_needed_for(affected_files)
+    owners_db = input_api.owners_db
+    owners_db.override_files = {}
+    owners_db.load_data_needed_for(affected_files)
     return []
   except Exception as e:
     return [output_api.PresubmitError(
@@ -892,8 +984,8 @@ def CheckOwners(input_api, output_api, source_file_filter=None):
         output_fn('Missing %s for these files:\n    %s' %
                   (needed, '\n    '.join(sorted(missing_files))))]
     if input_api.tbr and affects_owners:
-      output_list.append(output_fn('Note that TBR does not apply to changes '
-                                   'that affect OWNERS files.'))
+      output_list.append(output_fn('The CL affects an OWNERS file, so TBR will '
+                                   'be ignored.'))
     if not input_api.is_committing:
       suggested_owners = owners_db.reviewers_for(missing_files, owner_email)
       owners_with_comments = []
@@ -1060,18 +1152,27 @@ def PanProjectChecks(input_api, output_api,
   return results
 
 
-def CheckPatchFormatted(
-    input_api, output_api, check_js=False, check_python=False,
-    result_factory=None):
+def CheckPatchFormatted(input_api,
+                        output_api,
+                        bypass_warnings=True,
+                        check_js=False,
+                        check_python=None,
+                        result_factory=None):
   result_factory = result_factory or output_api.PresubmitPromptWarning
   import git_cl
 
   display_args = []
   if check_js:
     display_args.append('--js')
-  if check_python:
-    # --python requires --full
-    display_args.extend(['--python', '--full'])
+
+  # Explicitly setting check_python to will enable/disable python formatting
+  # on all files. Leaving it as None will enable checking patch formatting
+  # on files that have a .style.yapf file in a parent directory.
+  if check_python is not None:
+    if check_python:
+      display_args.append('--python')
+    else:
+      display_args.append('--no-python')
 
   cmd = ['-C', input_api.change.RepositoryRoot(),
          'cl', 'format', '--dry-run', '--presubmit'] + display_args
@@ -1084,8 +1185,11 @@ def CheckPatchFormatted(
   # contains the PRESUBMIT.py.
   if presubmit_subdir:
     cmd.append(input_api.PresubmitLocalPath())
-  code, _ = git_cl.RunGitWithCode(cmd, suppress_stderr=True)
-  if code == 2:
+  code, _ = git_cl.RunGitWithCode(cmd, suppress_stderr=bypass_warnings)
+  # bypass_warnings? Only fail with code 2.
+  # As this is just a warning, ignore all other errors if the user
+  # happens to have a broken clang-format, doesn't use git, etc etc.
+  if code == 2 or (code and not bypass_warnings):
     if presubmit_subdir:
       short_path = presubmit_subdir
     else:
@@ -1095,8 +1199,6 @@ def CheckPatchFormatted(
       'The %s directory requires source formatting. '
       'Please run: git cl format %s' %
       (short_path, ' '.join(display_args)))]
-  # As this is just a warning, ignore all other errors if the user
-  # happens to have a broken clang-format, doesn't use git, etc etc.
   return []
 
 
@@ -1181,6 +1283,29 @@ def CheckCIPDPackages(input_api, output_api, platforms, packages):
   return CheckCIPDManifest(input_api, output_api, content='\n'.join(manifest))
 
 
+def CheckCIPDClientDigests(input_api, output_api, client_version_file):
+  """Verifies that *.digests file was correctly regenerated.
+
+  <client_version_file>.digests file contains pinned hashes of the CIPD client.
+  It is consulted during CIPD client bootstrap and self-update. It should be
+  regenerated each time CIPD client version file changes.
+
+  Args:
+    client_version_file (str): Path to a text file with CIPD client version.
+  """
+  cmd = [
+    'cipd' if not input_api.is_windows else 'cipd.bat',
+    'selfupdate-roll', '-check', '-version-file', client_version_file,
+  ]
+  if input_api.verbose:
+    cmd += ['-log-level', 'debug']
+  return input_api.Command(
+      'Check CIPD client_version_file.digests file',
+      cmd,
+      {'shell': True} if input_api.is_windows else {},  # to resolve cipd.bat
+      output_api.PresubmitError)
+
+
 def CheckVPythonSpec(input_api, output_api, file_filter=None):
   """Validates any changed .vpython files with vpython verification tool.
 
@@ -1277,7 +1402,7 @@ def CheckChangedLUCIConfigs(input_api, output_api):
     ('%s/' % cs['location']) == loc_pref
   }
   cs_to_files = collections.defaultdict(list)
-  for f in input_api.AffectedFiles():
+  for f in input_api.AffectedFiles(include_deletes=False):
     # windows
     file_path = f.LocalPath().replace(_os.sep, '/')
     logging.debug('Affected file path: %s', file_path)
@@ -1307,3 +1432,37 @@ def CheckChangedLUCIConfigs(input_api, output_api):
         out_f = output_api.PresubmitNotifyResult
       outputs.append(out_f('Config validation: %s' % msg['text']))
   return outputs
+
+
+def CheckLucicfgGenOutput(input_api, output_api, entry_script):
+  """Verifies configs produced by `lucicfg` are up-to-date and pass validation.
+
+  Runs the check unconditionally, regardless of what files are modified. Examine
+  input_api.AffectedFiles() yourself before using CheckLucicfgGenOutput if this
+  is a concern.
+
+  Assumes `lucicfg` binary is in PATH and the user is logged in.
+
+  Args:
+    entry_script: path to the entry-point *.star script responsible for
+        generating a single config set. Either absolute or relative to the
+        currently running PRESUBMIT.py script.
+
+  Returns:
+    A list of input_api.Command objects containing verification commands.
+  """
+  return [
+      input_api.Command(
+        'lucicfg validate "%s"' % entry_script,
+        [
+            'lucicfg' if not input_api.is_windows else 'lucicfg.bat',
+            'validate', entry_script,
+            '-log-level', 'debug' if input_api.verbose else 'warning',
+        ],
+        {
+          'stderr': input_api.subprocess.STDOUT,
+          'shell': input_api.is_windows,  # to resolve *.bat
+          'cwd': input_api.PresubmitLocalPath(),
+        },
+        output_api.PresubmitError)
+  ]

data/vendor/depot_tools/presubmit_support.py

@@ -13,10 +13,10 @@ __version__ = '1.8.0'
 # change). We should add it as our presubmit scripts start feeling slow.
 
 import ast  # Exposed through the API.
-import cpplint
+import contextlib
 import cPickle  # Exposed through the API.
+import cpplint
 import cStringIO  # Exposed through the API.
-import contextlib
 import fnmatch  # Exposed through the API.
 import glob
 import inspect
@@ -44,6 +44,7 @@ from warnings import warn
 
 # Local imports.
 import fix_encoding
+import gclient_paths  # Exposed through the API
 import gclient_utils
 import git_footers
 import gerrit_util
@@ -437,39 +438,6 @@ class OutputApi(object):
       return self.PresubmitNotifyResult(*args, **kwargs)
     return self.PresubmitPromptWarning(*args, **kwargs)
 
-  def EnsureCQIncludeTrybotsAreAdded(self, cl, bots_to_include, message):
-    """Helper for any PostUploadHook wishing to add CQ_INCLUDE_TRYBOTS.
-
-    Merges the bots_to_include into the current CQ_INCLUDE_TRYBOTS list,
-    keeping it alphabetically sorted. Returns the results that should be
-    returned from the PostUploadHook.
-
-    Args:
-      cl: The git_cl.Changelist object.
-      bots_to_include: A list of strings of bots to include, in the form
-        "master:slave".
-      message: A message to be printed in the case that
-        CQ_INCLUDE_TRYBOTS was updated.
-    """
-    description = cl.GetDescription(force=True)
-    trybot_footers = git_footers.parse_footers(description).get(
-        git_footers.normalize_name('Cq-Include-Trybots'), [])
-    prior_bots = []
-    for f in trybot_footers:
-      prior_bots += [b.strip() for b in f.split(';') if b.strip()]
-
-    if set(prior_bots) >= set(bots_to_include):
-      return []
-    all_bots = ';'.join(sorted(set(prior_bots) | set(bots_to_include)))
-
-    description = git_footers.remove_footer(description, 'Cq-Include-Trybots')
-    description = git_footers.add_footer(
-        description, 'Cq-Include-Trybots', all_bots,
-        before_keys=['Change-Id'])
-
-    cl.UpdateDescription(description, force=True)
-    return [self.PresubmitNotifyResult(message)]
-
 
 class InputApi(object):
   """An instance of this object is passed to presubmit scripts so they can
@@ -549,15 +517,19 @@ class InputApi(object):
     self.cpplint = cpplint
     self.cStringIO = cStringIO
     self.fnmatch = fnmatch
+    self.gclient_paths = gclient_paths
+    # TODO(yyanagisawa): stop exposing this when python3 become default.
+    # Since python3's tempfile has TemporaryDirectory, we do not need this.
+    self.temporary_directory = gclient_utils.temporary_directory
     self.glob = glob.glob
     self.json = json
     self.logging = logging.getLogger('PRESUBMIT')
+    self.marshal = marshal
     self.os_listdir = os.listdir
-    self.os_walk = os.walk
     self.os_path = os.path
     self.os_stat = os.stat
+    self.os_walk = os.walk
     self.pickle = pickle
-    self.marshal = marshal
     self.re = re
     self.subprocess = subprocess
     self.tempfile = tempfile
@@ -761,6 +733,7 @@ class InputApi(object):
     # will run all tests once all PRESUBMIT files are processed.
     tests = []
     msgs = []
+    parallel = parallel and self.parallel
     for t in tests_mix:
       if isinstance(t, OutputApi.PresubmitResult) and t:
         msgs.append(t)
@@ -772,7 +745,7 @@ class InputApi(object):
         if not t.kwargs.get('cwd'):
           t.kwargs['cwd'] = self.PresubmitLocalPath()
     self.thread_pool.AddTests(tests, parallel)
-    if not self.parallel:
+    if not parallel:
       msgs.extend(self.thread_pool.RunAsync())
     return msgs
 
@@ -1063,7 +1036,11 @@ class Change(object):
   def BugsFromDescription(self):
     """Returns all bugs referenced in the commit description."""
     tags = [b.strip() for b in self.tags.get('BUG', '').split(',') if b.strip()]
-    footers = git_footers.parse_footers(self._full_description).get('Bug', [])
+    footers = []
+    unsplit_footers = git_footers.parse_footers(self._full_description).get(
+        'Bug', [])
+    for unsplit_footer in unsplit_footers:
+      footers += [b.strip() for b in unsplit_footer.split(',')]
     return sorted(set(tags + footers))
 
   def ReviewersFromDescription(self):
@@ -1529,8 +1506,8 @@ def DoPresubmitChecks(change,
       output.write("Warning, no PRESUBMIT.py found.\n")
     results = []
     thread_pool = ThreadPool()
-    executer = PresubmitExecuter(change, committing, verbose,
-                                 gerrit_obj, dry_run, thread_pool)
+    executer = PresubmitExecuter(change, committing, verbose, gerrit_obj,
+                                 dry_run, thread_pool, parallel)
     if default_presubmit:
       if verbose:
         output.write("Running default presubmit script.\n")