Presubmit tests: allow 100columns limit for .java files.

presubmit_canned_checks.py

 # 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.
 
 """Generic presubmit checks that can be reused by other presubmit checks."""
 
 
 ### Description checks
 
 def CheckChangeHasTestField(input_api, output_api):
@@ skipping 61 matching lines @@
   return []
 
 
 ### Content checks
 
 def CheckDoNotSubmitInFiles(input_api, output_api):
   """Checks that the user didn't add 'DO NOT ' + 'SUBMIT' to any files."""
   # We want to check every text file, not just source files.
   file_filter = lambda x : x
   keyword = 'DO NOT ' + 'SUBMIT'
-  errors = _FindNewViolationsOfRule(lambda line : keyword not in line,
+  errors = _FindNewViolationsOfRule(lambda _, line : keyword not in line,
                                     input_api, file_filter)
   text = '\n'.join('Found %s in %s' % (keyword, loc) for loc in errors)
   if text:
     return [output_api.PresubmitError(text)]
   return []
 
 
 def CheckChangeLintsClean(input_api, output_api, source_file_filter=None):
   """Checks that all '.cc' and '.h' files pass cpplint.py."""
   _RE_IS_TEST = input_api.re.compile(r'.*tests?.(cc|h)$')
@@ skipping 134 matching lines @@
 def _ReportErrorFileAndLine(filename, line_num, line):
   """Default error formatter for _FindNewViolationsOfRule."""
   return '%s, line %s' % (filename, line_num)
 
 
 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 line of input and returning True
-      if the rule is satisfied and False if there was a problem.
+    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.
   """
   errors = []
   for f in input_api.AffectedFiles(include_deletes=False,
                                    file_filter=source_file_filter):
     # 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.
-    if all(callable_rule(line) for line in f.NewContents()):
+    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.
 
     for line_num, line in f.ChangedContents():
-      if not callable_rule(line):
+      if not callable_rule(extension, line):
         errors.append(error_formatter(f.LocalPath(), line_num, line))
 
   return errors
 
 
 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.
   """
   # In addition to the filter, make sure that makefiles are blacklisted.
   if not source_file_filter:
     # It's the default filter.
     source_file_filter = input_api.FilterSourceFile
   def filter_more(affected_file):
     return (not input_api.os_path.basename(affected_file.LocalPath()) in
                 ('Makefile', 'makefile') and
             source_file_filter(affected_file))
 
-  tabs = _FindNewViolationsOfRule(lambda line : '\t' not in line,
+  tabs = _FindNewViolationsOfRule(lambda _, line : '\t' not in line,
                                   input_api, filter_more)
 
   if tabs:
     return [output_api.PresubmitPromptWarning('Found a tab character in:',
                                               long_text='\n'.join(tabs))]
   return []
 
 
 def CheckChangeTodoHasOwner(input_api, output_api, source_file_filter=None):
   """Checks that the user didn't add TODO(name) without an owner."""
 
   unowned_todo = input_api.re.compile('TO' + 'DO[^(]')
-  errors = _FindNewViolationsOfRule(lambda x : not unowned_todo.search(x),
+  errors = _FindNewViolationsOfRule(lambda _, x : not unowned_todo.search(x),
                                     input_api, source_file_filter)
   errors = ['Found TO' + 'DO with no owner in ' + x for x in errors]
   if errors:
     return [output_api.PresubmitPromptWarning('\n'.join(errors))]
   return []
 
 
 def CheckChangeHasNoStrayWhitespace(input_api, output_api,
                                     source_file_filter=None):
   """Checks that there is no stray whitespace at source lines end."""
-  errors = _FindNewViolationsOfRule(lambda line : line.rstrip() == line,
+  errors = _FindNewViolationsOfRule(lambda _, line : line.rstrip() == line,
                                     input_api, source_file_filter)
   if errors:
     return [output_api.PresubmitPromptWarning(
         'Found line ending with white spaces in:',
         long_text='\n'.join(errors))]
   return []
 
 
 def CheckLongLines(input_api, output_api, maxlen=80, source_file_filter=None):
   """Checks that there aren't any lines longer than maxlen characters in any of
   the text files to be submitted.
   """
-  # Stupidly long symbols that needs to be worked around if takes 66% of line.
-  long_symbol = maxlen * 2 / 3
-  # Hard line length limit at 50% more.
-  extra_maxlen = maxlen * 3 / 2
+  maxlens = { 
+      'java': 100, 
+      '': maxlen,
+  }
   # Note: these are C++ specific but processed on all languages. :(
   MACROS = ('#define', '#include', '#import', '#pragma', '#if', '#endif')
 
-  def no_long_lines(line):
-    if len(line) <= maxlen:
+  def no_long_lines(file_extension, line):
+    file_maxlen = maxlens.get(file_extension, maxlens[''])
+    # Stupidly long symbols that needs to be worked around if takes 66% of line.
+    long_symbol = file_maxlen * 2 / 3
+    # Hard line length limit at 50% more.
+    extra_maxlen = file_maxlen * 3 / 2
+
+    line_len = len(line)
+    if line_len <= file_maxlen:
       return True
 
-    if len(line) > extra_maxlen:
+    if line_len > extra_maxlen:
       return False
 
     return (
         line.startswith(MACROS) or
         any((url in line) for url in ('http://', 'https://')) or
         input_api.re.match(
           r'.*[A-Za-z][A-Za-z_0-9]{%d,}.*' % long_symbol, line))
 
   def format_error(filename, line_num, line):
     return '%s, line %s, %s chars' % (filename, line_num, len(line))
@@ skipping 578 matching lines @@
     results.extend(input_api.canned_checks.CheckSvnForCommonMimeTypes(
         input_api, output_api))
     snapshot("checking license")
     results.extend(input_api.canned_checks.CheckLicense(
         input_api, output_api, license_header, source_file_filter=sources))
     snapshot("checking was uploaded")
     results.extend(input_api.canned_checks.CheckChangeWasUploaded(
         input_api, output_api))
   snapshot("done")
   return results