gclient: remove wildcard import from git_scm
Part of a larger refactoring to abstract SCM-specific bits.
presubmit_support, revert, gcl: modify to import gclient_scm and gclient_utils
Part of a larger refactoring to abstract SCM-specific bits.
revert, gcl: modify to import gclient_scm and gclient_utils
Part of a larger refactoring to abstract SCM-specific bits.
gclient: pull out SCM bits
Pulled out SCMWrapper into gcliet_scm.py as part of a larger refactoring to
abstract SCM-specific bits. Plan is to evenutally add git support.
Pulling out SCMWrapper also required pulling out utility functions into
a gclient_utility.py.
Patch contributed by msb@
TEST=none
BUG=none
git-svn-id: svn://svn.chromium.org/chrome/trunk/tools/depot_tools@26423 0039d316-1c4b-4281-b951-d872f2087c98
diff --git a/gclient.py b/gclient.py
index 743557c..e56a56a 100755
--- a/gclient.py
+++ b/gclient.py
@@ -73,16 +73,14 @@
import os
import re
import stat
-import subprocess
import sys
import time
import urlparse
-import xml.dom.minidom
import urllib
-
-SVN_COMMAND = "svn"
-
+import gclient_scm
+import gclient_utils
+from gclient_utils import Error, FileRead, FileWrite
# default help text
DEFAULT_USAGE_TEXT = (
@@ -288,774 +286,6 @@
""")
-## Generic utils
-
-def ParseXML(output):
- try:
- return xml.dom.minidom.parseString(output)
- except xml.parsers.expat.ExpatError:
- return None
-
-
-def GetNamedNodeText(node, node_name):
- child_nodes = node.getElementsByTagName(node_name)
- if not child_nodes:
- return None
- assert len(child_nodes) == 1 and child_nodes[0].childNodes.length == 1
- return child_nodes[0].firstChild.nodeValue
-
-
-def GetNodeNamedAttributeText(node, node_name, attribute_name):
- child_nodes = node.getElementsByTagName(node_name)
- if not child_nodes:
- return None
- assert len(child_nodes) == 1
- return child_nodes[0].getAttribute(attribute_name)
-
-
-class Error(Exception):
- """gclient exception class."""
- pass
-
-class PrintableObject(object):
- def __str__(self):
- output = ''
- for i in dir(self):
- if i.startswith('__'):
- continue
- output += '%s = %s\n' % (i, str(getattr(self, i, '')))
- return output
-
-
-def FileRead(filename):
- content = None
- f = open(filename, "rU")
- try:
- content = f.read()
- finally:
- f.close()
- return content
-
-
-def FileWrite(filename, content):
- f = open(filename, "w")
- try:
- f.write(content)
- finally:
- f.close()
-
-
-def RemoveDirectory(*path):
- """Recursively removes a directory, even if it's marked read-only.
-
- Remove the directory located at *path, if it exists.
-
- shutil.rmtree() doesn't work on Windows if any of the files or directories
- are read-only, which svn repositories and some .svn files are. We need to
- be able to force the files to be writable (i.e., deletable) as we traverse
- the tree.
-
- Even with all this, Windows still sometimes fails to delete a file, citing
- a permission error (maybe something to do with antivirus scans or disk
- indexing). The best suggestion any of the user forums had was to wait a
- bit and try again, so we do that too. It's hand-waving, but sometimes it
- works. :/
-
- On POSIX systems, things are a little bit simpler. The modes of the files
- to be deleted doesn't matter, only the modes of the directories containing
- them are significant. As the directory tree is traversed, each directory
- has its mode set appropriately before descending into it. This should
- result in the entire tree being removed, with the possible exception of
- *path itself, because nothing attempts to change the mode of its parent.
- Doing so would be hazardous, as it's not a directory slated for removal.
- In the ordinary case, this is not a problem: for our purposes, the user
- will never lack write permission on *path's parent.
- """
- file_path = os.path.join(*path)
- if not os.path.exists(file_path):
- return
-
- if os.path.islink(file_path) or not os.path.isdir(file_path):
- raise Error("RemoveDirectory asked to remove non-directory %s" % file_path)
-
- has_win32api = False
- if sys.platform == 'win32':
- has_win32api = True
- # Some people don't have the APIs installed. In that case we'll do without.
- try:
- win32api = __import__('win32api')
- win32con = __import__('win32con')
- except ImportError:
- has_win32api = False
- else:
- # On POSIX systems, we need the x-bit set on the directory to access it,
- # the r-bit to see its contents, and the w-bit to remove files from it.
- # The actual modes of the files within the directory is irrelevant.
- os.chmod(file_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
- for fn in os.listdir(file_path):
- fullpath = os.path.join(file_path, fn)
-
- # If fullpath is a symbolic link that points to a directory, isdir will
- # be True, but we don't want to descend into that as a directory, we just
- # want to remove the link. Check islink and treat links as ordinary files
- # would be treated regardless of what they reference.
- if os.path.islink(fullpath) or not os.path.isdir(fullpath):
- if sys.platform == 'win32':
- os.chmod(fullpath, stat.S_IWRITE)
- if has_win32api:
- win32api.SetFileAttributes(fullpath, win32con.FILE_ATTRIBUTE_NORMAL)
- try:
- os.remove(fullpath)
- except OSError, e:
- if e.errno != errno.EACCES or sys.platform != 'win32':
- raise
- print 'Failed to delete %s: trying again' % fullpath
- time.sleep(0.1)
- os.remove(fullpath)
- else:
- RemoveDirectory(fullpath)
-
- if sys.platform == 'win32':
- os.chmod(file_path, stat.S_IWRITE)
- if has_win32api:
- win32api.SetFileAttributes(file_path, win32con.FILE_ATTRIBUTE_NORMAL)
- try:
- os.rmdir(file_path)
- except OSError, e:
- if e.errno != errno.EACCES or sys.platform != 'win32':
- raise
- print 'Failed to remove %s: trying again' % file_path
- time.sleep(0.1)
- os.rmdir(file_path)
-
-
-def SubprocessCall(command, in_directory, fail_status=None):
- """Runs command, a list, in directory in_directory.
-
- This function wraps SubprocessCallAndFilter, but does not perform the
- filtering functions. See that function for a more complete usage
- description.
- """
- # Call subprocess and capture nothing:
- SubprocessCallAndFilter(command, in_directory, True, True, fail_status)
-
-
-def SubprocessCallAndFilter(command,
- in_directory,
- print_messages,
- print_stdout,
- fail_status=None, filter=None):
- """Runs command, a list, in directory in_directory.
-
- If print_messages is true, a message indicating what is being done
- is printed to stdout. If print_stdout is true, the command's stdout
- is also forwarded to stdout.
-
- If a filter function is specified, it is expected to take a single
- string argument, and it will be called with each line of the
- subprocess's output. Each line has had the trailing newline character
- trimmed.
-
- If the command fails, as indicated by a nonzero exit status, gclient will
- exit with an exit status of fail_status. If fail_status is None (the
- default), gclient will raise an Error exception.
- """
-
- if print_messages:
- print("\n________ running \'%s\' in \'%s\'"
- % (' '.join(command), in_directory))
-
- # *Sigh*: Windows needs shell=True, or else it won't search %PATH% for the
- # executable, but shell=True makes subprocess on Linux fail when it's called
- # with a list because it only tries to execute the first item in the list.
- kid = subprocess.Popen(command, bufsize=0, cwd=in_directory,
- shell=(sys.platform == 'win32'), stdout=subprocess.PIPE)
-
- # Also, we need to forward stdout to prevent weird re-ordering of output.
- # This has to be done on a per byte basis to make sure it is not buffered:
- # normally buffering is done for each line, but if svn requests input, no
- # end-of-line character is output after the prompt and it would not show up.
- in_byte = kid.stdout.read(1)
- in_line = ""
- while in_byte:
- if in_byte != "\r":
- if print_stdout:
- sys.stdout.write(in_byte)
- if in_byte != "\n":
- in_line += in_byte
- if in_byte == "\n" and filter:
- filter(in_line)
- in_line = ""
- in_byte = kid.stdout.read(1)
- rv = kid.wait()
-
- if rv:
- msg = "failed to run command: %s" % " ".join(command)
-
- if fail_status != None:
- print >>sys.stderr, msg
- sys.exit(fail_status)
-
- raise Error(msg)
-
-
-def IsUsingGit(root, paths):
- """Returns True if we're using git to manage any of our checkouts.
- |entries| is a list of paths to check."""
- for path in paths:
- if os.path.exists(os.path.join(root, path, '.git')):
- return True
- return False
-
-# -----------------------------------------------------------------------------
-# SVN utils:
-
-
-def RunSVN(args, in_directory):
- """Runs svn, sending output to stdout.
-
- Args:
- args: A sequence of command line parameters to be passed to svn.
- in_directory: The directory where svn is to be run.
-
- Raises:
- Error: An error occurred while running the svn command.
- """
- c = [SVN_COMMAND]
- c.extend(args)
-
- SubprocessCall(c, in_directory)
-
-
-def CaptureSVN(args, in_directory=None, print_error=True):
- """Runs svn, capturing output sent to stdout as a string.
-
- Args:
- args: A sequence of command line parameters to be passed to svn.
- in_directory: The directory where svn is to be run.
-
- Returns:
- The output sent to stdout as a string.
- """
- c = [SVN_COMMAND]
- c.extend(args)
-
- # *Sigh*: Windows needs shell=True, or else it won't search %PATH% for
- # the svn.exe executable, but shell=True makes subprocess on Linux fail
- # when it's called with a list because it only tries to execute the
- # first string ("svn").
- stderr = None
- if not print_error:
- stderr = subprocess.PIPE
- return subprocess.Popen(c,
- cwd=in_directory,
- shell=(sys.platform == 'win32'),
- stdout=subprocess.PIPE,
- stderr=stderr).communicate()[0]
-
-
-def RunSVNAndGetFileList(args, in_directory, file_list):
- """Runs svn checkout, update, or status, output to stdout.
-
- The first item in args must be either "checkout", "update", or "status".
-
- svn's stdout is parsed to collect a list of files checked out or updated.
- These files are appended to file_list. svn's stdout is also printed to
- sys.stdout as in RunSVN.
-
- Args:
- args: A sequence of command line parameters to be passed to svn.
- in_directory: The directory where svn is to be run.
-
- Raises:
- Error: An error occurred while running the svn command.
- """
- command = [SVN_COMMAND]
- command.extend(args)
-
- # svn update and svn checkout use the same pattern: the first three columns
- # are for file status, property status, and lock status. This is followed
- # by two spaces, and then the path to the file.
- update_pattern = '^... (.*)$'
-
- # The first three columns of svn status are the same as for svn update and
- # svn checkout. The next three columns indicate addition-with-history,
- # switch, and remote lock status. This is followed by one space, and then
- # the path to the file.
- status_pattern = '^...... (.*)$'
-
- # args[0] must be a supported command. This will blow up if it's something
- # else, which is good. Note that the patterns are only effective when
- # these commands are used in their ordinary forms, the patterns are invalid
- # for "svn status --show-updates", for example.
- pattern = {
- 'checkout': update_pattern,
- 'status': status_pattern,
- 'update': update_pattern,
- }[args[0]]
-
- compiled_pattern = re.compile(pattern)
-
- def CaptureMatchingLines(line):
- match = compiled_pattern.search(line)
- if match:
- file_list.append(match.group(1))
-
- RunSVNAndFilterOutput(args,
- in_directory,
- True,
- True,
- CaptureMatchingLines)
-
-def RunSVNAndFilterOutput(args,
- in_directory,
- print_messages,
- print_stdout,
- filter):
- """Runs svn checkout, update, status, or diff, optionally outputting
- to stdout.
-
- The first item in args must be either "checkout", "update",
- "status", or "diff".
-
- svn's stdout is passed line-by-line to the given filter function. If
- print_stdout is true, it is also printed to sys.stdout as in RunSVN.
-
- Args:
- args: A sequence of command line parameters to be passed to svn.
- in_directory: The directory where svn is to be run.
- print_messages: Whether to print status messages to stdout about
- which Subversion commands are being run.
- print_stdout: Whether to forward Subversion's output to stdout.
- filter: A function taking one argument (a string) which will be
- passed each line (with the ending newline character removed) of
- Subversion's output for filtering.
-
- Raises:
- Error: An error occurred while running the svn command.
- """
- command = [SVN_COMMAND]
- command.extend(args)
-
- SubprocessCallAndFilter(command,
- in_directory,
- print_messages,
- print_stdout,
- filter=filter)
-
-def CaptureSVNInfo(relpath, in_directory=None, print_error=True):
- """Returns a dictionary from the svn info output for the given file.
-
- Args:
- relpath: The directory where the working copy resides relative to
- the directory given by in_directory.
- in_directory: The directory where svn is to be run.
- """
- output = CaptureSVN(["info", "--xml", relpath], in_directory, print_error)
- dom = ParseXML(output)
- result = {}
- if dom:
- def C(item, f):
- if item is not None: return f(item)
- # /info/entry/
- # url
- # reposityory/(root|uuid)
- # wc-info/(schedule|depth)
- # commit/(author|date)
- # str() the results because they may be returned as Unicode, which
- # interferes with the higher layers matching up things in the deps
- # dictionary.
- # TODO(maruel): Fix at higher level instead (!)
- result['Repository Root'] = C(GetNamedNodeText(dom, 'root'), str)
- result['URL'] = C(GetNamedNodeText(dom, 'url'), str)
- result['UUID'] = C(GetNamedNodeText(dom, 'uuid'), str)
- result['Revision'] = C(GetNodeNamedAttributeText(dom, 'entry', 'revision'),
- int)
- result['Node Kind'] = C(GetNodeNamedAttributeText(dom, 'entry', 'kind'),
- str)
- result['Schedule'] = C(GetNamedNodeText(dom, 'schedule'), str)
- result['Path'] = C(GetNodeNamedAttributeText(dom, 'entry', 'path'), str)
- result['Copied From URL'] = C(GetNamedNodeText(dom, 'copy-from-url'), str)
- result['Copied From Rev'] = C(GetNamedNodeText(dom, 'copy-from-rev'), str)
- return result
-
-
-def CaptureSVNHeadRevision(url):
- """Get the head revision of a SVN repository.
-
- Returns:
- Int head revision
- """
- info = CaptureSVN(["info", "--xml", url], os.getcwd())
- dom = xml.dom.minidom.parseString(info)
- return int(dom.getElementsByTagName('entry')[0].getAttribute('revision'))
-
-
-def CaptureSVNStatus(files):
- """Returns the svn 1.5 svn status emulated output.
-
- @files can be a string (one file) or a list of files.
-
- Returns an array of (status, file) tuples."""
- command = ["status", "--xml"]
- if not files:
- pass
- elif isinstance(files, basestring):
- command.append(files)
- else:
- command.extend(files)
-
- status_letter = {
- None: ' ',
- '': ' ',
- 'added': 'A',
- 'conflicted': 'C',
- 'deleted': 'D',
- 'external': 'X',
- 'ignored': 'I',
- 'incomplete': '!',
- 'merged': 'G',
- 'missing': '!',
- 'modified': 'M',
- 'none': ' ',
- 'normal': ' ',
- 'obstructed': '~',
- 'replaced': 'R',
- 'unversioned': '?',
- }
- dom = ParseXML(CaptureSVN(command))
- results = []
- if dom:
- # /status/target/entry/(wc-status|commit|author|date)
- for target in dom.getElementsByTagName('target'):
- base_path = target.getAttribute('path')
- for entry in target.getElementsByTagName('entry'):
- file = entry.getAttribute('path')
- wc_status = entry.getElementsByTagName('wc-status')
- assert len(wc_status) == 1
- # Emulate svn 1.5 status ouput...
- statuses = [' ' for i in range(7)]
- # Col 0
- xml_item_status = wc_status[0].getAttribute('item')
- if xml_item_status in status_letter:
- statuses[0] = status_letter[xml_item_status]
- else:
- raise Exception('Unknown item status "%s"; please implement me!' %
- xml_item_status)
- # Col 1
- xml_props_status = wc_status[0].getAttribute('props')
- if xml_props_status == 'modified':
- statuses[1] = 'M'
- elif xml_props_status == 'conflicted':
- statuses[1] = 'C'
- elif (not xml_props_status or xml_props_status == 'none' or
- xml_props_status == 'normal'):
- pass
- else:
- raise Exception('Unknown props status "%s"; please implement me!' %
- xml_props_status)
- # Col 2
- if wc_status[0].getAttribute('wc-locked') == 'true':
- statuses[2] = 'L'
- # Col 3
- if wc_status[0].getAttribute('copied') == 'true':
- statuses[3] = '+'
- item = (''.join(statuses), file)
- results.append(item)
- return results
-
-
-### SCM abstraction layer
-
-
-class SCMWrapper(object):
- """Add necessary glue between all the supported SCM.
-
- This is the abstraction layer to bind to different SCM. Since currently only
- subversion is supported, a lot of subersionism remains. This can be sorted out
- once another SCM is supported."""
- def __init__(self, url=None, root_dir=None, relpath=None,
- scm_name='svn'):
- # TODO(maruel): Deduce the SCM from the url.
- self.scm_name = scm_name
- self.url = url
- self._root_dir = root_dir
- if self._root_dir:
- self._root_dir = self._root_dir.replace('/', os.sep)
- self.relpath = relpath
- if self.relpath:
- self.relpath = self.relpath.replace('/', os.sep)
-
- def FullUrlForRelativeUrl(self, url):
- # Find the forth '/' and strip from there. A bit hackish.
- return '/'.join(self.url.split('/')[:4]) + url
-
- def RunCommand(self, command, options, args, file_list=None):
- # file_list will have all files that are modified appended to it.
-
- if file_list == None:
- file_list = []
-
- commands = {
- 'cleanup': self.cleanup,
- 'export': self.export,
- 'update': self.update,
- 'revert': self.revert,
- 'status': self.status,
- 'diff': self.diff,
- 'pack': self.pack,
- 'runhooks': self.status,
- }
-
- if not command in commands:
- raise Error('Unknown command %s' % command)
-
- return commands[command](options, args, file_list)
-
- def cleanup(self, options, args, file_list):
- """Cleanup working copy."""
- command = ['cleanup']
- command.extend(args)
- RunSVN(command, os.path.join(self._root_dir, self.relpath))
-
- def diff(self, options, args, file_list):
- # NOTE: This function does not currently modify file_list.
- command = ['diff']
- command.extend(args)
- RunSVN(command, os.path.join(self._root_dir, self.relpath))
-
- def export(self, options, args, file_list):
- assert len(args) == 1
- export_path = os.path.abspath(os.path.join(args[0], self.relpath))
- try:
- os.makedirs(export_path)
- except OSError:
- pass
- assert os.path.exists(export_path)
- command = ['export', '--force', '.']
- command.append(export_path)
- RunSVN(command, os.path.join(self._root_dir, self.relpath))
-
- def update(self, options, args, file_list):
- """Runs SCM to update or transparently checkout the working copy.
-
- All updated files will be appended to file_list.
-
- Raises:
- Error: if can't get URL for relative path.
- """
- # Only update if git is not controlling the directory.
- checkout_path = os.path.join(self._root_dir, self.relpath)
- git_path = os.path.join(self._root_dir, self.relpath, '.git')
- if os.path.exists(git_path):
- print("________ found .git directory; skipping %s" % self.relpath)
- return
-
- if args:
- raise Error("Unsupported argument(s): %s" % ",".join(args))
-
- url = self.url
- components = url.split("@")
- revision = None
- forced_revision = False
- if options.revision:
- # Override the revision number.
- url = '%s@%s' % (components[0], str(options.revision))
- revision = int(options.revision)
- forced_revision = True
- elif len(components) == 2:
- revision = int(components[1])
- forced_revision = True
-
- rev_str = ""
- if revision:
- rev_str = ' at %d' % revision
-
- if not os.path.exists(checkout_path):
- # We need to checkout.
- command = ['checkout', url, checkout_path]
- if revision:
- command.extend(['--revision', str(revision)])
- RunSVNAndGetFileList(command, self._root_dir, file_list)
- return
-
- # Get the existing scm url and the revision number of the current checkout.
- from_info = CaptureSVNInfo(os.path.join(checkout_path, '.'), '.')
- if not from_info:
- raise Error("Can't update/checkout %r if an unversioned directory is "
- "present. Delete the directory and try again." %
- checkout_path)
-
- if options.manually_grab_svn_rev:
- # Retrieve the current HEAD version because svn is slow at null updates.
- if not revision:
- from_info_live = CaptureSVNInfo(from_info['URL'], '.')
- revision = int(from_info_live['Revision'])
- rev_str = ' at %d' % revision
-
- if from_info['URL'] != components[0]:
- to_info = CaptureSVNInfo(url, '.')
- can_switch = ((from_info['Repository Root'] != to_info['Repository Root'])
- and (from_info['UUID'] == to_info['UUID']))
- if can_switch:
- print("\n_____ relocating %s to a new checkout" % self.relpath)
- # We have different roots, so check if we can switch --relocate.
- # Subversion only permits this if the repository UUIDs match.
- # Perform the switch --relocate, then rewrite the from_url
- # to reflect where we "are now." (This is the same way that
- # Subversion itself handles the metadata when switch --relocate
- # is used.) This makes the checks below for whether we
- # can update to a revision or have to switch to a different
- # branch work as expected.
- # TODO(maruel): TEST ME !
- command = ["switch", "--relocate",
- from_info['Repository Root'],
- to_info['Repository Root'],
- self.relpath]
- RunSVN(command, self._root_dir)
- from_info['URL'] = from_info['URL'].replace(
- from_info['Repository Root'],
- to_info['Repository Root'])
- else:
- if CaptureSVNStatus(checkout_path):
- raise Error("Can't switch the checkout to %s; UUID don't match and "
- "there is local changes in %s. Delete the directory and "
- "try again." % (url, checkout_path))
- # Ok delete it.
- print("\n_____ switching %s to a new checkout" % self.relpath)
- RemoveDirectory(checkout_path)
- # We need to checkout.
- command = ['checkout', url, checkout_path]
- if revision:
- command.extend(['--revision', str(revision)])
- RunSVNAndGetFileList(command, self._root_dir, file_list)
- return
-
-
- # If the provided url has a revision number that matches the revision
- # number of the existing directory, then we don't need to bother updating.
- if not options.force and from_info['Revision'] == revision:
- if options.verbose or not forced_revision:
- print("\n_____ %s%s" % (self.relpath, rev_str))
- return
-
- command = ["update", checkout_path]
- if revision:
- command.extend(['--revision', str(revision)])
- RunSVNAndGetFileList(command, self._root_dir, file_list)
-
- def revert(self, options, args, file_list):
- """Reverts local modifications. Subversion specific.
-
- All reverted files will be appended to file_list, even if Subversion
- doesn't know about them.
- """
- path = os.path.join(self._root_dir, self.relpath)
- if not os.path.isdir(path):
- # svn revert won't work if the directory doesn't exist. It needs to
- # checkout instead.
- print("\n_____ %s is missing, synching instead" % self.relpath)
- # Don't reuse the args.
- return self.update(options, [], file_list)
-
- files = CaptureSVNStatus(path)
- # Batch the command.
- files_to_revert = []
- for file in files:
- file_path = os.path.join(path, file[1])
- print(file_path)
- # Unversioned file or unexpected unversioned file.
- if file[0][0] in ('?', '~'):
- # Remove extraneous file. Also remove unexpected unversioned
- # directories. svn won't touch them but we want to delete these.
- file_list.append(file_path)
- try:
- os.remove(file_path)
- except EnvironmentError:
- RemoveDirectory(file_path)
-
- if file[0][0] != '?':
- # For any other status, svn revert will work.
- file_list.append(file_path)
- files_to_revert.append(file[1])
-
- # Revert them all at once.
- if files_to_revert:
- accumulated_paths = []
- accumulated_length = 0
- command = ['revert']
- for p in files_to_revert:
- # Some shell have issues with command lines too long.
- if accumulated_length and accumulated_length + len(p) > 3072:
- RunSVN(command + accumulated_paths,
- os.path.join(self._root_dir, self.relpath))
- accumulated_paths = []
- accumulated_length = 0
- else:
- accumulated_paths.append(p)
- accumulated_length += len(p)
- if accumulated_paths:
- RunSVN(command + accumulated_paths,
- os.path.join(self._root_dir, self.relpath))
-
- def status(self, options, args, file_list):
- """Display status information."""
- path = os.path.join(self._root_dir, self.relpath)
- command = ['status']
- command.extend(args)
- if not os.path.isdir(path):
- # svn status won't work if the directory doesn't exist.
- print("\n________ couldn't run \'%s\' in \'%s\':\nThe directory "
- "does not exist."
- % (' '.join(command), path))
- # There's no file list to retrieve.
- else:
- RunSVNAndGetFileList(command, path, file_list)
-
- def pack(self, options, args, file_list):
- """Generates a patch file which can be applied to the root of the
- repository."""
- path = os.path.join(self._root_dir, self.relpath)
- command = ['diff']
- command.extend(args)
- # Simple class which tracks which file is being diffed and
- # replaces instances of its file name in the original and
- # working copy lines of the svn diff output.
- class DiffFilterer(object):
- index_string = "Index: "
- original_prefix = "--- "
- working_prefix = "+++ "
-
- def __init__(self, relpath):
- # Note that we always use '/' as the path separator to be
- # consistent with svn's cygwin-style output on Windows
- self._relpath = relpath.replace("\\", "/")
- self._current_file = ""
- self._replacement_file = ""
-
- def SetCurrentFile(self, file):
- self._current_file = file
- # Note that we always use '/' as the path separator to be
- # consistent with svn's cygwin-style output on Windows
- self._replacement_file = self._relpath + '/' + file
-
- def ReplaceAndPrint(self, line):
- print(line.replace(self._current_file, self._replacement_file))
-
- def Filter(self, line):
- if (line.startswith(self.index_string)):
- self.SetCurrentFile(line[len(self.index_string):])
- self.ReplaceAndPrint(line)
- else:
- if (line.startswith(self.original_prefix) or
- line.startswith(self.working_prefix)):
- self.ReplaceAndPrint(line)
- else:
- print line
-
- filterer = DiffFilterer(self.relpath)
- RunSVNAndFilterOutput(command, path, False, False, filterer.Filter)
-
## GClient implementation.
@@ -1325,7 +555,8 @@
raise Error(
"relative DEPS entry \"%s\" must begin with a slash" % d)
# Create a scm just to query the full url.
- scm = SCMWrapper(solution["url"], self._root_dir, None)
+ scm = gclient_scm.SCMWrapper(solution["url"], self._root_dir,
+ None)
url = scm.FullUrlForRelativeUrl(url)
if d in deps and deps[d] != url:
raise Error(
@@ -1354,7 +585,7 @@
# Use a discrete exit status code of 2 to indicate that a hook action
# failed. Users of this script may wish to treat hook action failures
# differently from VC failures.
- SubprocessCall(command, self._root_dir, fail_status=2)
+ gclient_utils.SubprocessCall(command, self._root_dir, fail_status=2)
def _RunHooks(self, command, file_list, is_using_git):
"""Evaluates all hooks, running actions as needed.
@@ -1441,7 +672,7 @@
entries[name] = url
if run_scm:
self._options.revision = revision_overrides.get(name)
- scm = SCMWrapper(url, self._root_dir, name)
+ scm = gclient_scm.SCMWrapper(url, self._root_dir, name)
scm.RunCommand(command, self._options, args, file_list)
file_list = [os.path.join(name, file.strip()) for file in file_list]
self._options.revision = None
@@ -1467,7 +698,7 @@
entries[d] = url
if run_scm:
self._options.revision = revision_overrides.get(d)
- scm = SCMWrapper(url, self._root_dir, d)
+ scm = gclient_scm.SCMWrapper(url, self._root_dir, d)
scm.RunCommand(command, self._options, args, file_list)
self._options.revision = None
@@ -1484,7 +715,7 @@
entries[d] = url
if run_scm:
self._options.revision = revision_overrides.get(d)
- scm = SCMWrapper(url, self._root_dir, d)
+ scm = gclient_scm.SCMWrapper(url, self._root_dir, d)
scm.RunCommand(command, self._options, args, file_list)
self._options.revision = None
@@ -1503,7 +734,7 @@
while file_list[i].startswith('\\') or file_list[i].startswith('/'):
file_list[i] = file_list[i][1:]
- is_using_git = IsUsingGit(self._root_dir, entries.keys())
+ is_using_git = gclient_utils.IsUsingGit(self._root_dir, entries.keys())
self._RunHooks(command, file_list, is_using_git)
if command == 'update':
@@ -1529,7 +760,7 @@
# Delete the entry
print("\n________ deleting \'%s\' " +
"in \'%s\'") % (entry_fixed, self._root_dir)
- RemoveDirectory(e_dir)
+ gclient_utils.RemoveDirectory(e_dir)
# record the current list of entries for next time
self._SaveEntries(entries)