Split (1)

train · 303k rows

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

rem stringlengths 0 322k	add stringlengths 0 2.05M	context stringlengths 8 228k
if exclude is not None and exclude(name):	head, tail = os.path.split(name) if tail in ('.svn', '.git'):	def add(self, name, arcname=None, recursive=True, exclude=None): if exclude is not None and exclude(name): return tarfile.TarFile.add(self, name, arcname=arcname, recursive=recursive)
def ShouldExcludePath(path): head, tail = os.path.split(path) if tail in ('.svn', '.git'): return True if not options.remove_nonessential_files: return False for nonessential_dir in NONESSENTIAL_DIRS: if path.startswith(os.path.join(GetSourceDirectory(), nonessential_dir)): return True return False		def ShouldExcludePath(path): head, tail = os.path.split(path) if tail in ('.svn', '.git'): return True
archive.add(GetSourceDirectory(), arcname=output_basename, exclude=ShouldExcludePath)	archive.add(GetSourceDirectory(), arcname=output_basename)	def ShouldExcludePath(path): head, tail = os.path.split(path) if tail in ('.svn', '.git'): return True
def port_fallbacks(): """Get the port fallback information. Returns: A dictionary mapping platform name to a list of other platforms to fall back on. All platforms fall back on 'base'. """ fallbacks = {_BASE_PLATFORM: []} for port_name in os.listdir(os.path.join('LayoutTests', 'platform')): try: platforms = port_facto...	class MockExecutive(object): last_run_command = [] response = '' class Executive(object): def run_command(self, args, cwd=None, input=None, error_handler=None, return_exit_code=False, return_stderr=True, decode_output=True): MockExecutive.last_run_command += [args] return MockExecutive.response	def port_fallbacks(): """Get the port fallback information. Returns: A dictionary mapping platform name to a list of other platforms to fall back on. All platforms fall back on 'base'. """ fallbacks = {_BASE_PLATFORM: []} for port_name in os.listdir(os.path.join('LayoutTests', 'platform')): try: platforms = port_facto...
def parse_git_output(git_output, glob_pattern): """Parses the output of git ls-tree and filters based on glob_pattern. Args: git_output: result of git ls-tree -r HEAD LayoutTests. glob_pattern: a pattern to filter the files. Returns: A dictionary mapping (test name, hash of content) => [paths] """ hashes = collections....	class ListDuplicatesTest(unittest.TestCase): def setUp(self): MockExecutive.last_run_command = [] MockExecutive.response = '' deduplicate_tests.executive = MockExecutive	def parse_git_output(git_output, glob_pattern): """Parses the output of git ls-tree and filters based on glob_pattern. Args: git_output: result of git ls-tree -r HEAD LayoutTests. glob_pattern: a pattern to filter the files. Returns: A dictionary mapping (test name, hash of content) => [paths] """ hashes = collections....
def cluster_file_hashes(glob_pattern): """Get the hashes of all the test expectations in the tree. We cheat and use git's hashes. Args: glob_pattern: a pattern to filter the files. Returns: A dictionary mapping (test name, hash of content) => [paths] """	hashes = deduplicate_tests.parse_git_output(git_output, '*.png') expected = {('animage.png', 'abcdebc762e3aec5df03b5c04485b2cb3b65ffb1'): set(['platform/chromium-linux/animage.png', 'platform/chromium-win/animage.png'])} self.assertEquals(expected, hashes)	def cluster_file_hashes(glob_pattern): """Get the hashes of all the test expectations in the tree. We cheat and use git's hashes. Args: glob_pattern: a pattern to filter the files. Returns: A dictionary mapping (test name, hash of content) => [paths] """ # A map of file hash => set of all files with that hash. hashes ...
hashes = collections.defaultdict(set)	def test_extract_platforms(self): self.assertEquals({'foo': 'platform/foo/bar', 'zoo': 'platform/zoo/com'}, deduplicate_tests.extract_platforms(['platform/foo/bar', 'platform/zoo/com'])) self.assertEquals({'foo': 'platform/foo/bar', deduplicate_tests._BASE_PLATFORM: 'what/'}, deduplicate_tests.extract_platforms(['platf...	def cluster_file_hashes(glob_pattern): """Get the hashes of all the test expectations in the tree. We cheat and use git's hashes. Args: glob_pattern: a pattern to filter the files. Returns: A dictionary mapping (test name, hash of content) => [paths] """ # A map of file hash => set of all files with that hash. hashes ...
cmd = ('git', 'ls-tree', '-r', 'HEAD', 'LayoutTests') try: git_output = executive.Executive().run_command(cmd) except OSError, e: if e.errno == 2: _log.error("Error: 'No such file' when running git.") _log.error("This script requires git.") sys.exit(1) raise e return parse_git_output(git_output, glob_pattern)	def test_unique(self): MockExecutive.response = ( '100644 blob 5053240b3353f6eb39f7cb00259785f16d121df2\tLayoutTests/mac/foo-expected.txt\n' '100644 blob a004548d107ecc4e1ea08019daf0a14e8634a1ff\tLayoutTests/platform/chromium/foo-expected.txt\n' '100644 blob abcd0bc762e3aec5df03b5c04485b2cb3b65ffb1\tLayoutTests/platfor...	def cluster_file_hashes(glob_pattern): """Get the hashes of all the test expectations in the tree. We cheat and use git's hashes. Args: glob_pattern: a pattern to filter the files. Returns: A dictionary mapping (test name, hash of content) => [paths] """ # A map of file hash => set of all files with that hash. hashes ...
def extract_platforms(paths): """Extracts the platforms from a list of paths matching ^platform/(.?)/. Args: paths: a list of paths. Returns: A dictionary containing all platforms from paths. """ platforms = {} for path in paths: match = re.match(r'^platform/(.?)/', path) if match: platform = match.group(1) else: pla...	result = deduplicate_tests.deduplicate('*') self.assertEquals(1, len(MockExecutive.last_run_command)) self.assertEquals(('git', 'ls-tree', '-r', 'HEAD', 'LayoutTests'), MockExecutive.last_run_command[-1]) self.assertEquals(2, len(result)) self.assertEquals({'test': 'animage.png', 'path': 'platform/chromium-linux/animag...	def extract_platforms(paths): """Extracts the platforms from a list of paths matching ^platform/(.?)/. Args: paths: a list of paths. Returns: A dictionary containing all platforms from paths. """ platforms = {} for path in paths: match = re.match(r'^platform/(.?)/', path) if match: platform = match.group(1) else: pla...
def find_dups(hashes, port_fallbacks): """Yields info about redundant test expectations. Args: hashes: a list of hashes as returned by cluster_file_hashes. port_fallbacks: a list of fallback information as returned by get_port_fallbacks. Returns: a tuple containing (test, platform, fallback, platforms) """ for (test, h...	result = deduplicate_tests.deduplicate('*.png') self.assertEquals(3, len(MockExecutive.last_run_command)) self.assertEquals(('git', 'ls-tree', '-r', 'HEAD', 'LayoutTests'), MockExecutive.last_run_command[-1]) self.assertEquals(1, len(result)) self.assertEquals({'test': 'animage.png', 'path': 'platform/chromium-linux/an...	def find_dups(hashes, port_fallbacks): """Yields info about redundant test expectations. Args: hashes: a list of hashes as returned by cluster_file_hashes. port_fallbacks: a list of fallback information as returned by get_port_fallbacks. Returns: a tuple containing (test, platform, fallback, platforms) """ for (test, h...
print run_command(self.status_command(), error_handler=Executive.ignore_error)	print self.run(self.status_command(), error_handler=Executive.ignore_error)	def ensure_clean_working_directory(self, force_clean): if not force_clean and not self.working_directory_is_clean(): # FIXME: Shouldn't this use cwd=self.checkout_root? print run_command(self.status_command(), error_handler=Executive.ignore_error) raise ScriptError(message="Working directory has modifications, pass --f...
for line in run_command(status_command, cwd=self.checkout_root).splitlines():	for line in self.run(status_command, cwd=self.checkout_root).splitlines():	def run_status_and_extract_filenames(self, status_command, status_regexp): filenames = [] # We run with cwd=self.checkout_root so that returned-paths are root-relative. for line in run_command(status_command, cwd=self.checkout_root).splitlines(): match = re.search(status_regexp, line) if not match: continue # status = ...
find_output = run_command(find_args, cwd=home_directory, error_handler=Executive.ignore_error).rstrip()	find_output = self.run(find_args, cwd=home_directory, error_handler=Executive.ignore_error).rstrip()	def has_authorization_for_realm(self, realm=svn_server_realm, home_directory=os.getenv("HOME")): # Assumes find and grep are installed. if not os.path.isdir(os.path.join(home_directory, ".subversion")): return False find_args = ["find", ".subversion", "-type", "f", "-exec", "grep", "-q", realm, "{}", ";", "-print"]; fi...
self.cached_version = run_command(['svn', '--version', '--quiet'])	self.cached_version = self.run(['svn', '--version', '--quiet'])	def svn_version(self): if not self.cached_version: self.cached_version = run_command(['svn', '--version', '--quiet']) return self.cached_version
return run_command(["svn", "diff"], cwd=self.checkout_root, decode_output=False) == ""	return self.run(["svn", "diff"], cwd=self.checkout_root, decode_output=False) == ""	def working_directory_is_clean(self): return run_command(["svn", "diff"], cwd=self.checkout_root, decode_output=False) == ""
run_command(["svn", "revert", "-R", "."], cwd=self.checkout_root)	self.run(["svn", "revert", "-R", "."], cwd=self.checkout_root)	def clean_working_directory(self): # svn revert -R is not as awesome as git reset --hard. # It will leave added files around, causing later svn update # calls to fail on the bots. We make this mirror git reset --hard # by deleting any added files as well. added_files = reversed(sorted(self.added_files())) # added_file...
run_command(["svn", "add", path])	self.run(["svn", "add", path])	def add(self, path): # path is assumed to be cwd relative? run_command(["svn", "add", path])
return run_command([self.script_path("svn-create-patch")],	return self.run([self.script_path("svn-create-patch")],	def create_patch(self, git_commit=None, squash=None): """Returns a byte array (str()) representing the patch file. Patch files are effectively binary since they may contain files of multiple different encodings.""" return run_command([self.script_path("svn-create-patch")], cwd=self.checkout_root, return_stderr=False, d...
return run_command(["svn", "propget", "svn:author", "--revprop", "-r", revision]).rstrip()	return self.run(["svn", "propget", "svn:author", "--revprop", "-r", revision]).rstrip()	def committer_email_for_revision(self, revision): return run_command(["svn", "propget", "svn:author", "--revprop", "-r", revision]).rstrip()
return run_command(["svn", "cat", "-r", revision, remote_path], decode_output=False)	return self.run(["svn", "cat", "-r", revision, remote_path], decode_output=False)	def contents_at_revision(self, path, revision): """Returns a byte array (str()) containing the contents of path @ revision in the repository.""" remote_path = "%s/%s" % (self._repository_url(), path) return run_command(["svn", "cat", "-r", revision, remote_path], decode_output=False)
return run_command(['svn', 'diff', '-c', revision])	return self.run(['svn', 'diff', '-c', revision])	def diff_for_revision(self, revision): # FIXME: This should probably use cwd=self.checkout_root return run_command(['svn', 'diff', '-c', revision])
run_command(svn_merge_args)	self.run(svn_merge_args)	def apply_reverse_diff(self, revision): # '-c -revision' applies the inverse diff of 'revision' svn_merge_args = ['svn', 'merge', '--non-interactive', '-c', '-%s' % revision, self._repository_url()] log("WARNING: svn merge has been known to take more than 10 minutes to complete. It is recommended you use git for rollo...
run_command(['svn', 'revert'] + file_paths)	self.run(['svn', 'revert'] + file_paths)	def revert_files(self, file_paths): # FIXME: This should probably use cwd=self.checkout_root. run_command(['svn', 'revert'] + file_paths)
return run_command(svn_commit_args, error_handler=commit_error_handler)	return self.run(svn_commit_args, error_handler=commit_error_handler)	def commit_with_message(self, message, username=None, git_commit=None, squash=None): # squash and git-commit are not used by SVN. if self.dryrun: # Return a string which looks like a commit so that things which parse this output will succeed. return "Dry run, no commit.\nCommitted revision 0." svn_commit_args = ["svn",...
return run_command(['svn', 'log', '--non-interactive', '--revision', svn_revision]);	return self.run(['svn', 'log', '--non-interactive', '--revision', svn_revision])	def svn_commit_log(self, svn_revision): svn_revision = self.strip_r_from_svn_revision(svn_revision) return run_command(['svn', 'log', '--non-interactive', '--revision', svn_revision]);
run_command(['git', 'reset', '--hard', self.svn_branch_name()])	self.run(['git', 'reset', '--hard', self.svn_branch_name()])	def discard_local_commits(self): # FIXME: This should probably use cwd=self.checkout_root run_command(['git', 'reset', '--hard', self.svn_branch_name()])
return run_command(['git', 'log', '--pretty=oneline', 'HEAD...' + self.svn_branch_name()]).splitlines()	return self.run(['git', 'log', '--pretty=oneline', 'HEAD...' + self.svn_branch_name()]).splitlines()	def local_commits(self): # FIXME: This should probably use cwd=self.checkout_root return run_command(['git', 'log', '--pretty=oneline', 'HEAD...' + self.svn_branch_name()]).splitlines()
return run_command(['git', 'diff', 'HEAD', '--name-only']) == ""	return self.run(['git', 'diff', 'HEAD', '--name-only']) == ""	def working_directory_is_clean(self): # FIXME: This should probably use cwd=self.checkout_root return run_command(['git', 'diff', 'HEAD', '--name-only']) == ""
run_command(['git', 'reset', '--hard', 'HEAD'])	self.run(['git', 'reset', '--hard', 'HEAD'])	def clean_working_directory(self): # FIXME: These should probably use cwd=self.checkout_root. # Could run git clean here too, but that wouldn't match working_directory_is_clean run_command(['git', 'reset', '--hard', 'HEAD']) # Aborting rebase even though this does not match working_directory_is_clean if self.rebase_in_...
run_command(['git', 'rebase', '--abort'])	self.run(['git', 'rebase', '--abort'])	def clean_working_directory(self): # FIXME: These should probably use cwd=self.checkout_root. # Could run git clean here too, but that wouldn't match working_directory_is_clean run_command(['git', 'reset', '--hard', 'HEAD']) # Aborting rebase even though this does not match working_directory_is_clean if self.rebase_in_...
run_command(["git", "add", path])	self.run(["git", "add", path])	def add(self, path): # path is assumed to be cwd relative? run_command(["git", "add", path])
changed_files = run_command(["git", "show", "--pretty=format:", "--name-only", git_commit]).splitlines()	changed_files = self.run(["git", "show", "--pretty=format:", "--name-only", git_commit]).splitlines()	def _changes_files_for_commit(self, git_commit): # --pretty="format:" makes git show not print the commit log header, changed_files = run_command(["git", "show", "--pretty=format:", "--name-only", git_commit]).splitlines() # instead it just prints a blank line at the top, so we skip the blank line: return changed_files...
return run_command(['git', 'diff', '--binary', "--no-ext-diff", "--full-index", "-M", self._merge_base(git_commit, squash)], decode_output=False)	return self.run(['git', 'diff', '--binary', "--no-ext-diff", "--full-index", "-M", self._merge_base(git_commit, squash)], decode_output=False)	def create_patch(self, git_commit=None, squash=None): """Returns a byte array (str()) representing the patch file. Patch files are effectively binary since they may contain files of multiple different encodings.""" # FIXME: This should probably use cwd=self.checkout_root return run_command(['git', 'diff', '--binary', "...
return run_command(["git", "show", "%s:%s" % (self.git_commit_from_svn_revision(revision), path)], decode_output=False)	return self.run(["git", "show", "%s:%s" % (self.git_commit_from_svn_revision(revision), path)], decode_output=False)	def contents_at_revision(self, path, revision): """Returns a byte array (str()) containing the contents of path @ revision in the repository.""" return run_command(["git", "show", "%s:%s" % (self.git_commit_from_svn_revision(revision), path)], decode_output=False)
committer_email = run_command(["git", "log", "-1", "--pretty=format:%ce", git_commit])	committer_email = self.run(["git", "log", "-1", "--pretty=format:%ce", git_commit])	def committer_email_for_revision(self, revision): git_commit = self.git_commit_from_svn_revision(revision) committer_email = run_command(["git", "log", "-1", "--pretty=format:%ce", git_commit]) # Git adds an extra @repository_hash to the end of every committer email, remove it: return committer_email.rsplit("@", 1)[0]
run_command(['git', 'revert', '--no-commit', git_commit], error_handler=Executive.ignore_error)	self.run(['git', 'revert', '--no-commit', git_commit], error_handler=Executive.ignore_error)	def apply_reverse_diff(self, revision): # Assume the revision is an svn revision. git_commit = self.git_commit_from_svn_revision(revision) # I think this will always fail due to ChangeLogs. run_command(['git', 'revert', '--no-commit', git_commit], error_handler=Executive.ignore_error)
run_command(['git', 'checkout', 'HEAD'] + file_paths)	self.run(['git', 'checkout', 'HEAD'] + file_paths)	def revert_files(self, file_paths): run_command(['git', 'checkout', 'HEAD'] + file_paths)
run_command(['git', 'reset', '--soft', self.svn_branch_name()])	self.run(['git', 'reset', '--soft', self.svn_branch_name()])	def commit_with_message(self, message, username=None, git_commit=None, squash=None): # Username is ignored during Git commits. if git_commit: # Need working directory changes to be committed so we can checkout the merge branch. if not self.working_directory_is_clean(): # FIXME: webkit-patch land will modify the ChangeL...
branch_ref = run_command(['git', 'symbolic-ref', 'HEAD']).strip()	branch_ref = self.run(['git', 'symbolic-ref', 'HEAD']).strip()	def _commit_on_branch(self, message, git_commit): branch_ref = run_command(['git', 'symbolic-ref', 'HEAD']).strip() branch_name = branch_ref.replace('refs/heads/', '') commit_ids = self.commit_ids_from_commitish_arguments([git_commit])
run_command(['git', 'checkout', '-q', '-b', MERGE_BRANCH, self.svn_branch_name()])	self.run(['git', 'checkout', '-q', '-b', MERGE_BRANCH, self.svn_branch_name()])	def _commit_on_branch(self, message, git_commit): branch_ref = run_command(['git', 'symbolic-ref', 'HEAD']).strip() branch_name = branch_ref.replace('refs/heads/', '') commit_ids = self.commit_ids_from_commitish_arguments([git_commit])