« back to all changes in this revision
Viewing changes to bzrlib/add.py
- browse files at revision 2568.2.4
- compare with another revision
- download diff
- download tarball
- view history from revision 2568.2.4
- Committer: Robert Collins
- Date: 2007-07-03 02:33:32 UTC
- mto: This revision was merged to the branch mainline in revision 2581.
- Revision ID: robertc@robertcollins.net-20070703023332-jz0qdt2dwhzjuhlc
* ``bzrlib.add.smart_add`` and ``bzrlib.add.smart_add_tree`` are now
deprecated in favour of ``MutableTree.smart_add``. (Robert Collins,
Martin Pool)
deprecated in favour of ``MutableTree.smart_add``. (Robert Collins,
Martin Pool)
added
removed
bzrlib/add.py
18
18
19
19
import errno
20
20
import os
21
from os.path import dirname
22
21
import sys
23
22
24
23
import bzrlib.bzrdir
25
24
import bzrlib.errors as errors
26
from bzrlib.errors import NotBranchError
27
from bzrlib.inventory import InventoryEntry
28
25
import bzrlib.osutils
29
26
from bzrlib.symbol_versioning import *
30
from bzrlib.trace import mutter, note, warning
31
27
from bzrlib.workingtree import WorkingTree
32
28
33
29
124
120
For the specific behaviour see the help for cmd_add().
125
121
126
122
Returns the number of files added.
127
Please see smart_add_tree for more detail.
123
Deprecated in 0.18. Please use MutableTree.smart_add.
128
124
"""
129
125
tree = WorkingTree.open_containing(file_list[0])[0]
130
126
return smart_add_tree(tree, file_list, recurse, action=action, save=save)
131
127
132
128
133
class FastPath(object):
134
"""A path object with fast accessors for things like basename."""
135
136
__slots__ = ['raw_path', 'base_path']
137
138
def __init__(self, path, base_path=None):
139
"""Construct a FastPath from path."""
140
if base_path is None:
141
self.base_path = bzrlib.osutils.basename(path)
142
else:
143
self.base_path = base_path
144
self.raw_path = path
145
146
def __cmp__(self, other):
147
return cmp(self.raw_path, other.raw_path)
148
149
def __hash__(self):
150
return hash(self.raw_path)
151
152
129
@deprecated_function(zero_eighteen)
153
130
def smart_add_tree(tree, file_list, recurse=True, action=None, save=True):
154
"""Add files to version, optionally recursing into directories.
155
156
This is designed more towards DWIM for humans than API simplicity.
157
For the specific behaviour see the help for cmd_add().
158
159
This calls reporter with each (path, kind, file_id) of added files.
160
161
Returns the number of files added.
162
163
:param save: Save the inventory after completing the adds. If False this
164
provides dry-run functionality by doing the add and not saving the
165
inventory. Note that the modified inventory is left in place, allowing
166
further dry-run tasks to take place. To restore the original inventory
167
call tree.read_working_inventory().
168
"""
169
tree.lock_tree_write()
170
try:
171
return _smart_add_tree(tree=tree, file_list=file_list, recurse=recurse,
172
action=action, save=save)
173
finally:
174
tree.unlock()
175
176
177
def _smart_add_tree(tree, file_list, recurse=True, action=None, save=True):
178
"""Helper for smart_add_tree.
179
180
The tree should be locked before entering this function. See smart_add_tree
181
for parameter definitions.
182
"""
183
assert isinstance(recurse, bool)
184
if action is None:
185
action = AddAction()
186
187
if not file_list:
188
# no paths supplied: add the entire tree.
189
file_list = [u'.']
190
mutter("smart add of %r")
191
inv = tree.read_working_inventory()
192
added = []
193
ignored = {}
194
dirs_to_add = []
195
user_dirs = set()
196
197
# validate user file paths and convert all paths to tree
198
# relative : its cheaper to make a tree relative path an abspath
199
# than to convert an abspath to tree relative.
200
for filepath in file_list:
201
rf = FastPath(tree.relpath(filepath))
202
# validate user parameters. Our recursive code avoids adding new files
203
# that need such validation
204
if tree.is_control_filename(rf.raw_path):
205
raise errors.ForbiddenControlFileError(filename=rf.raw_path)
206
207
abspath = tree.abspath(rf.raw_path)
208
kind = bzrlib.osutils.file_kind(abspath)
209
if kind == 'directory':
210
# schedule the dir for scanning
211
user_dirs.add(rf)
212
else:
213
if not InventoryEntry.versionable_kind(kind):
214
raise errors.BadFileKindError(filename=abspath, kind=kind)
215
# ensure the named path is added, so that ignore rules in the later directory
216
# walk dont skip it.
217
# we dont have a parent ie known yet.: use the relatively slower inventory
218
# probing method
219
versioned = inv.has_filename(rf.raw_path)
220
if versioned:
221
continue
222
added.extend(__add_one_and_parent(tree, inv, None, rf, kind, action))
223
224
if not recurse:
225
# no need to walk any directories at all.
226
if len(added) > 0 and save:
227
tree._write_inventory(inv)
228
return added, ignored
229
230
# only walk the minimal parents needed: we have user_dirs to override
231
# ignores.
232
prev_dir = None
233
234
is_inside = bzrlib.osutils.is_inside_or_parent_of_any
235
for path in sorted(user_dirs):
236
if (prev_dir is None or not is_inside([prev_dir], path.raw_path)):
237
dirs_to_add.append((path, None))
238
prev_dir = path.raw_path
239
240
# this will eventually be *just* directories, right now it starts off with
241
# just directories.
242
for directory, parent_ie in dirs_to_add:
243
# directory is tree-relative
244
abspath = tree.abspath(directory.raw_path)
245
246
# get the contents of this directory.
247
248
# find the kind of the path being added.
249
kind = bzrlib.osutils.file_kind(abspath)
250
251
if not InventoryEntry.versionable_kind(kind):
252
warning("skipping %s (can't add file of kind '%s')", abspath, kind)
253
continue
254
255
if parent_ie is not None:
256
versioned = directory.base_path in parent_ie.children
257
else:
258
# without the parent ie, use the relatively slower inventory
259
# probing method
260
versioned = inv.has_filename(directory.raw_path)
261
262
if kind == 'directory':
263
try:
264
sub_branch = bzrlib.bzrdir.BzrDir.open(abspath)
265
sub_tree = True
266
except NotBranchError:
267
sub_tree = False
268
except errors.UnsupportedFormatError:
269
sub_tree = True
270
else:
271
sub_tree = False
272
273
if directory.raw_path == '':
274
# mutter("tree root doesn't need to be added")
275
sub_tree = False
276
elif versioned:
277
pass
278
# mutter("%r is already versioned", abspath)
279
elif sub_tree:
280
# XXX: This is wrong; people *might* reasonably be trying to add
281
# subtrees as subtrees. This should probably only be done in formats
282
# which can represent subtrees, and even then perhaps only when
283
# the user asked to add subtrees. At the moment you can add them
284
# specially through 'join --reference', which is perhaps
285
# reasonable: adding a new reference is a special operation and
286
# can have a special behaviour. mbp 20070306
287
mutter("%r is a nested bzr tree", abspath)
288
else:
289
__add_one(tree, inv, parent_ie, directory, kind, action)
290
added.append(directory.raw_path)
291
292
if kind == 'directory' and not sub_tree:
293
if parent_ie is not None:
294
# must be present:
295
this_ie = parent_ie.children[directory.base_path]
296
else:
297
# without the parent ie, use the relatively slower inventory
298
# probing method
299
this_id = inv.path2id(directory.raw_path)
300
if this_id is None:
301
this_ie = None
302
else:
303
this_ie = inv[this_id]
304
305
for subf in sorted(os.listdir(abspath)):
306
# here we could use TreeDirectory rather than
307
# string concatenation.
308
subp = bzrlib.osutils.pathjoin(directory.raw_path, subf)
309
# TODO: is_control_filename is very slow. Make it faster.
310
# TreeDirectory.is_control_filename could also make this
311
# faster - its impossible for a non root dir to have a
312
# control file.
313
if tree.is_control_filename(subp):
314
mutter("skip control directory %r", subp)
315
elif subf in this_ie.children:
316
# recurse into this already versioned subdir.
317
dirs_to_add.append((FastPath(subp, subf), this_ie))
318
else:
319
# user selection overrides ignoes
320
# ignore while selecting files - if we globbed in the
321
# outer loop we would ignore user files.
322
ignore_glob = tree.is_ignored(subp)
323
if ignore_glob is not None:
324
# mutter("skip ignored sub-file %r", subp)
325
ignored.setdefault(ignore_glob, []).append(subp)
326
else:
327
#mutter("queue to add sub-file %r", subp)
328
dirs_to_add.append((FastPath(subp, subf), this_ie))
329
330
if len(added) > 0 and save:
331
tree._write_inventory(inv)
332
return added, ignored
333
334
335
def __add_one_and_parent(tree, inv, parent_ie, path, kind, action):
336
"""Add a new entry to the inventory and automatically add unversioned parents.
337
338
:param inv: Inventory which will receive the new entry.
339
:param parent_ie: Parent inventory entry if known, or None. If
340
None, the parent is looked up by name and used if present, otherwise it
341
is recursively added.
342
:param kind: Kind of new entry (file, directory, etc)
343
:param action: callback(inv, parent_ie, path, kind); return ignored.
344
:return: A list of paths which have been added.
345
"""
346
# Nothing to do if path is already versioned.
347
# This is safe from infinite recursion because the tree root is
348
# always versioned.
349
if parent_ie is not None:
350
# we have a parent ie already
351
added = []
352
else:
353
# slower but does not need parent_ie
354
if inv.has_filename(path.raw_path):
355
return []
356
# its really not there : add the parent
357
# note that the dirname use leads to some extra str copying etc but as
358
# there are a limited number of dirs we can be nested under, it should
359
# generally find it very fast and not recurse after that.
360
added = __add_one_and_parent(tree, inv, None, FastPath(dirname(path.raw_path)), 'directory', action)
361
parent_id = inv.path2id(dirname(path.raw_path))
362
parent_ie = inv[parent_id]
363
__add_one(tree, inv, parent_ie, path, kind, action)
364
return added + [path.raw_path]
365
366
367
def __add_one(tree, inv, parent_ie, path, kind, file_id_callback):
368
"""Add a new entry to the inventory.
369
370
:param inv: Inventory which will receive the new entry.
371
:param parent_ie: Parent inventory entry.
372
:param kind: Kind of new entry (file, directory, etc)
373
:param file_id_callback: callback(inv, parent_ie, path, kind); return a file_id
374
or None to generate a new file id
375
:returns: None
376
"""
377
file_id = file_id_callback(inv, parent_ie, path, kind)
378
entry = bzrlib.inventory.make_entry(kind, path.base_path, parent_ie.file_id,
379
file_id=file_id)
380
inv.add(entry)
131
"""Deprecated in 0.18. Please use MutableTree.smart_add."""
132
return tree.smart_add(file_list, recurse, action, save)
133
Loggerhead is a web-based interface for Breezy
Version: 2.0.1