← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/add.py

  • Committer: Robert Collins
  • Date: 2007-07-02 22:36:11 UTC
  • mto: This revision was merged to the branch mainline in revision 2581.
  • Revision ID: robertc@robertcollins.net-20070702223611-50tnzmbeoryqid75
* New method ``_glob_expand_file_list_if_needed`` on the ``Command`` class
  for dealing with unexpanded glob lists - e.g. on the win32 platform. This
  was moved from ``bzrlib.add._prepare_file_list``. (Robert Collins)

* ``bzrlib.add.smart_add_tree`` will no longer perform glob expansion on
  win32. Callers of the function should do this. (Robert Collins)

* ``bzrlib.add.glob_expand_for_win32`` is now
  ``bzrlib.win32utils.glob_expand``.  (Robert Collins)

* ``bzrlib.smart_add`` is deprecated. (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/add.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Helper functions for adding files to working trees."""
18
18
 
 
19
import errno
 
20
import os
 
21
from os.path import dirname
19
22
import sys
20
23
 
21
24
import bzrlib.bzrdir
 
25
import bzrlib.errors as errors
 
26
from bzrlib.errors import NotBranchError
 
27
from bzrlib.inventory import InventoryEntry
22
28
import bzrlib.osutils
23
29
from bzrlib.symbol_versioning import *
 
30
from bzrlib.trace import mutter, note, warning
 
31
from bzrlib.workingtree import WorkingTree
24
32
 
25
33
 
26
34
class AddAction(object):
31
39
 
32
40
        :param to_file: The stream to write into. This is expected to take
33
41
            Unicode paths. If not supplied, it will default to ``sys.stdout``.
34
 
        :param should_print: If False, printing will be suppressed.
 
42
        :param should_print: If False, printing will be supressed.
35
43
        """
36
44
        self._to_file = to_file
37
45
        if to_file is None:
50
58
        :param kind: The kind of the object being added.
51
59
        """
52
60
        if self.should_print:
53
 
            self._to_file.write('adding %s\n' % _quote(path.raw_path))
 
61
            self._to_file.write('added %s\n' % _quote(path.raw_path))
54
62
        return None
55
63
 
56
64
 
69
77
        file_id, base_path = self._get_base_file_id(path, parent_ie)
70
78
        if file_id is not None:
71
79
            if self.should_print:
72
 
                self._to_file.write('adding %s w/ file id from %s\n'
 
80
                self._to_file.write('added %s w/ file id from %s\n'
73
81
                                    % (path.raw_path, base_path))
74
82
        else:
75
83
            # we aren't doing anything special, so let the default
106
114
add_action_null = add_action_add
107
115
add_action_add_and_print = AddAction(should_print=True)
108
116
add_action_print = add_action_add_and_print
 
117
 
 
118
 
 
119
@deprecated_function(zero_eighteen)
 
120
def smart_add(file_list, recurse=True, action=None, save=True):
 
121
    """Add files to version, optionally recursing into directories.
 
122
 
 
123
    This is designed more towards DWIM for humans than API simplicity.
 
124
    For the specific behaviour see the help for cmd_add().
 
125
 
 
126
    Returns the number of files added.
 
127
    Please see smart_add_tree for more detail.
 
128
    """
 
129
    tree = WorkingTree.open_containing(file_list[0])[0]
 
130
    return smart_add_tree(tree, file_list, recurse, action=action, save=save)
 
131
 
 
132
 
 
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
 
 
153
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, action):
 
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 action: 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 = action(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)