1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
import os
from six.moves import cStringIO as StringIO
from fnmatch import fnmatch
from . import vcs
from .log import get_logger
from .utils import is_blacklisted, rel_path_to_url
def chunks(data, n):
for i in range(0, len(data) - 1, n):
yield data[i:i+n]
class TestTree(object):
def __init__(self, tests_root, url_base):
self.tests_root = tests_root
self.url_base = url_base
self.logger = get_logger()
def current_rev(self):
pass
def local_changes(self):
pass
def committed_changes(self, base_rev=None):
pass
class GitTree(TestTree):
def __init__(self, tests_root, url_base):
TestTree.__init__(self, tests_root, url_base)
self.git = self.setup_git()
def setup_git(self):
assert vcs.is_git_repo(self.tests_root)
return vcs.get_git_func(self.tests_root)
def current_rev(self):
return self.git("rev-parse", "HEAD").strip()
def local_changes(self, path=None):
# -z is stable like --porcelain; see the git status documentation for details
cmd = ["status", "-z", "--ignore-submodules=all"]
if path is not None:
cmd.extend(["--", path])
rv = {}
data = self.git(*cmd)
if data == "":
return rv
assert data[-1] == "\0"
f = StringIO(data)
while f.tell() < len(data):
# First two bytes are the status in the stage (index) and working tree, respectively
staged = f.read(1)
worktree = f.read(1)
assert f.read(1) == " "
if staged == "R":
# When a file is renamed, there are two files, the source and the destination
files = 2
else:
files = 1
filenames = []
for i in range(files):
filenames.append("")
char = f.read(1)
while char != "\0":
filenames[-1] += char
char = f.read(1)
if not is_blacklisted(rel_path_to_url(filenames[0], self.url_base)):
rv.update(self.local_status(staged, worktree, filenames))
return rv
def committed_changes(self, base_rev=None):
if base_rev is None:
self.logger.debug("Adding all changesets to the manifest")
return [(item, "modified") for item in self.paths()]
self.logger.debug("Updating the manifest from %s to %s" % (base_rev, self.current_rev()))
rv = []
data = self.git("diff", "-z", "--name-status", base_rev + "..HEAD")
items = data.split("\0")
for status, filename in chunks(items, 2):
if is_blacklisted(rel_path_to_url(filename, self.url_base)):
continue
if status == "D":
rv.append((filename, "deleted"))
else:
rv.append((filename, "modified"))
return rv
def paths(self):
data = self.git("ls-tree", "--name-only", "--full-tree", "-r", "HEAD")
return [item for item in data.split("\n") if not item.endswith(os.path.sep)]
def local_status(self, staged, worktree, filenames):
# Convert the complex range of statuses that git can have to two values
# we care about; "modified" and "deleted" and return a dictionary mapping
# filenames to statuses
rv = {}
if (staged, worktree) in [("D", "D"), ("A", "U"), ("U", "D"), ("U", "A"),
("D", "U"), ("A", "A"), ("U", "U")]:
raise Exception("Can't operate on tree containing unmerged paths")
if staged == "R":
assert len(filenames) == 2
dest, src = filenames
rv[dest] = "modified"
rv[src] = "deleted"
else:
assert len(filenames) == 1
filename = filenames[0]
if staged == "D" or worktree == "D":
# Actually if something is deleted in the index but present in the worktree
# it will get included by having a status of both "D " and "??".
# It isn't clear whether that's a bug
rv[filename] = "deleted"
elif staged == "?" and worktree == "?":
# A new file. If it's a directory, recurse into it
if os.path.isdir(os.path.join(self.tests_root, filename)):
if filename[-1] != '/':
filename += '/'
rv.update(self.local_changes(filename))
else:
rv[filename] = "modified"
else:
rv[filename] = "modified"
return rv
class NoVCSTree(TestTree):
"""Subclass that doesn't depend on git"""
ignore = ["*.py[c|0]", "*~", "#*"]
def current_rev(self):
return None
def local_changes(self):
# Put all files into local_changes and rely on Manifest.update to de-dupe
# changes that in fact committed at the base rev.
rv = []
for dir_path, dir_names, filenames in os.walk(self.tests_root):
for filename in filenames:
if any(fnmatch(filename, pattern) for pattern in self.ignore):
continue
rel_path = os.path.relpath(os.path.join(dir_path, filename),
self.tests_root)
if is_blacklisted(rel_path_to_url(rel_path, self.url_base)):
continue
rv.append((rel_path, "modified"))
return dict(rv)
def committed_changes(self, base_rev=None):
return None
|
