Add support for auto-props in the form: "*.sh = svn:eol-style=LF;svn:executable"

checkout.py

 # coding=utf8
 # Copyright (c) 2011 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.
 """Manages a project checkout.
 
 Includes support for svn, git-svn and git.
 """
 
 from __future__ import with_statement
@@ skipping 159 matching lines @@
   commit_pwd = None
   svn_url = None
   project_path = None
   # Override at class level when necessary. If used, --non-interactive is
   # implied.
   svn_config = SvnConfig()
   # Set to True when non-interactivity is necessary but a custom subversion
   # configuration directory is not necessary.
   non_interactive = False
 
-  def _add_svn_flags(self, args, non_interactive):
+  def _add_svn_flags(self, args, non_interactive, credentials=True):
     args = ['svn'] + args
     if not self.svn_config.default:
       args.extend(['--config-dir', self.svn_config.svn_config_dir])
     if not self.svn_config.default or self.non_interactive or non_interactive:
       args.append('--non-interactive')
-    if self.commit_user:
-      args.extend(['--username', self.commit_user])
-    if self.commit_pwd:
-      args.extend(['--password', self.commit_pwd])
+    if credentials:
+      if self.commit_user:
+        args.extend(['--username', self.commit_user])
+      if self.commit_pwd:
+        args.extend(['--password', self.commit_pwd])
     return args
 
   def _check_call_svn(self, args, **kwargs):
     """Runs svn and throws an exception if the command failed."""
     kwargs.setdefault('cwd', self.project_path)
     kwargs.setdefault('stdout', self.VOID)
     return subprocess2.check_call_out(
         self._add_svn_flags(args, False), **kwargs)
 
-  def _check_output_svn(self, args, **kwargs):
+  def _check_output_svn(self, args, credentials=True, **kwargs):
     """Runs svn and throws an exception if the command failed.
 
      Returns the output.
     """
     kwargs.setdefault('cwd', self.project_path)
-    return subprocess2.check_output(self._add_svn_flags(args, True), **kwargs)
+    return subprocess2.check_output(
+        self._add_svn_flags(args, True, credentials), **kwargs)
 
   @staticmethod
   def _parse_svn_info(output, key):
     """Returns value for key from svn info output.
 
     Case insensitive.
     """
     values = {}
     key = key.lower()
     for line in output.splitlines(False):
@@ skipping 25 matching lines @@
     revision = self._revert()
     if revision != self._last_seen_revision:
       logging.info('Updated at revision %d' % revision)
       self._last_seen_revision = revision
     return revision
 
   def apply_patch(self, patches, post_processor=None):
     post_processor = post_processor or []
     for p in patches:
       try:
+        # It is important to use credentials=False otherwise it could leak in
+        # the error message. It is not necessary here anyway.

[Dirk Pranke, 2011/05/30 20:10:59]

change "it" to "they" in "it could leak" and "it is not necessary"?

         stdout = ''
         if p.is_delete:
-          stdout += self._check_output_svn(['delete', p.filename, '--force'])
+          stdout += self._check_output_svn(
+              ['delete', p.filename, '--force'], credentials=False)
         else:
           new = not os.path.exists(p.filename)
 
           # svn add while creating directories otherwise svn add on the
           # contained files will silently fail.
           # First, find the root directory that exists.
           dirname = os.path.dirname(p.filename)
           dirs_to_create = []
           while (dirname and
               not os.path.isdir(os.path.join(self.project_path, dirname))):
             dirs_to_create.append(dirname)
             dirname = os.path.dirname(dirname)
           for dir_to_create in reversed(dirs_to_create):
             os.mkdir(os.path.join(self.project_path, dir_to_create))
             stdout += self._check_output_svn(
-                ['add', dir_to_create, '--force'])
+                ['add', dir_to_create, '--force'], credentials=False)
 
           if p.is_binary:
             with open(os.path.join(self.project_path, p.filename), 'wb') as f:
               f.write(p.get())
           else:
             cmd = ['patch', '-p%s' % p.patchlevel, '--forward', '--force']
             stdout += subprocess2.check_output(
                 cmd, stdin=p.get(), cwd=self.project_path)
           if new:
-            stdout += self._check_output_svn(['add', p.filename, '--force'])
+            stdout += self._check_output_svn(
+                ['add', p.filename, '--force'], credentials=False)
           for prop in p.svn_properties:
             stdout += self._check_output_svn(
-                ['propset', prop[0], prop[1], p.filename])
-          for prop, value in self.svn_config.auto_props.iteritems():
+                ['propset', prop[0], prop[1], p.filename], credentials=False)
+          for prop, values in self.svn_config.auto_props.iteritems():
             if fnmatch.fnmatch(p.filename, prop):
-              stdout += self._check_output_svn(
-                  ['propset'] + value.split('=', 1) + [p.filename])
+              for value in values.split(';'):
+                if '=' not in value:
+                  params = [value, '*']
+                else:
+                  params = value.split('=', 1)
+                stdout += self._check_output_svn(
+                    ['propset'] + params + [p.filename], credentials=False)
         for post in post_processor:
           post(self, p)
       except OSError, e:
         raise PatchApplicationFailed(p.filename, '%s%s' % (stdout, e))
       except subprocess.CalledProcessError, e:
         raise PatchApplicationFailed(
-            p.filename, '%s%s' % (stdout, getattr(e, 'stdout', '')))
+            p.filename,
+            'While running %s;\n%s%s' % (
+              ' '.join(e.cmd), stdout, getattr(e, 'stdout', '')))
 
   def commit(self, commit_message, user):
     logging.info('Committing patch for %s' % user)
     assert self.commit_user
     assert isinstance(commit_message, unicode)
     handle, commit_filename = tempfile.mkstemp(text=True)
     try:
       # Shouldn't assume default encoding is UTF-8. But really, if you are using
       # anything else, you are living in another world.
       os.write(handle, commit_message.encode('utf-8'))
@@ skipping 341 matching lines @@
         user, message))
     return 'FAKE'
 
   @property
   def project_name(self):
     return self.checkout.project_name
 
   @property
   def project_path(self):
     return self.checkout.project_path