← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

  • Committer: John Arbash Meinel
  • Date: 2009-02-23 15:29:35 UTC
  • mfrom: (3943.7.7 bzr.code_style_cleanup)
  • mto: This revision was merged to the branch mainline in revision 4033.
  • Revision ID: john@arbash-meinel.com-20090223152935-oel9m92mwcc6nb4h
Merge the removal of all trailing whitespace, and resolve conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/mutabletree.py
69
69
    entirely in memory.
70
70
 
71
71
    For now, we are not treating MutableTree as an interface to provide
72
 
    conformance tests for - rather we are testing MemoryTree specifically, and 
 
72
    conformance tests for - rather we are testing MemoryTree specifically, and
73
73
    interface testing implementations of WorkingTree.
74
74
 
75
75
    A mutable tree always has an associated Branch and BzrDir object - the
130
130
            if self.is_control_filename(f):
131
131
                raise errors.ForbiddenControlFileError(filename=f)
132
132
            fp = splitpath(f)
133
 
        # fill out file kinds for all files [not needed when we stop 
 
133
        # fill out file kinds for all files [not needed when we stop
134
134
        # caring about the instantaneous file kind within a uncommmitted tree
135
135
        #
136
136
        self._gather_kinds(files, kinds)
233
233
        In early tree formats the result of last_revision is the same as the
234
234
        branch last_revision, but that is no longer the case for modern tree
235
235
        formats.
236
 
        
 
236
 
237
237
        last_revision returns the left most parent id, or None if there are no
238
238
        parents.
239
239
 
256
256
    def lock_write(self):
257
257
        """Lock the tree and its branch. This allows mutating calls to be made.
258
258
 
259
 
        Some mutating methods will take out implicit write locks, but in 
 
259
        Some mutating methods will take out implicit write locks, but in
260
260
        general you should always obtain a write lock before calling mutating
261
261
        methods on a tree.
262
262
        """
278
278
        The intent of this function is to allow trees that have a hashcache to
279
279
        update the hashcache during commit. If the observed file is too new
280
280
        (based on the stat_value) to be safely hash-cached the tree will ignore
281
 
        it. 
 
281
        it.
282
282
 
283
283
        The default implementation does nothing.
284
284
 
298
298
    @needs_write_lock
299
299
    def put_file_bytes_non_atomic(self, file_id, bytes):
300
300
        """Update the content of a file in the tree.
301
 
        
 
301
 
302
302
        Note that the file is written in-place rather than being
303
303
        written to a temporary location and renamed. As a consequence,
304
304
        readers can potentially see the file half-written.
318
318
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
319
319
        """Set the parents of the working tree.
320
320
 
321
 
        :param parents_list: A list of (revision_id, tree) tuples. 
 
321
        :param parents_list: A list of (revision_id, tree) tuples.
322
322
            If tree is None, then that element is treated as an unreachable
323
323
            parent tree - i.e. a ghost.
324
324
        """
332
332
        For the specific behaviour see the help for cmd_add().
333
333
 
334
334
        :param action: A reporter to be called with the inventory, parent_ie,
335
 
            path and kind of the path being added. It may return a file_id if 
 
335
            path and kind of the path being added. It may return a file_id if
336
336
            a specific one should be used.
337
337
        :param save: Save the inventory after completing the adds. If False
338
338
            this provides dry-run functionality by doing the add and not saving
346
346
        from bzrlib.inventory import InventoryEntry
347
347
        if action is None:
348
348
            action = add.AddAction()
349
 
        
 
349
 
350
350
        if not file_list:
351
351
            # no paths supplied: add the entire tree.
352
352
            file_list = [u'.']
357
357
        dirs_to_add = []
358
358
        user_dirs = set()
359
359
 
360
 
        # validate user file paths and convert all paths to tree 
 
360
        # validate user file paths and convert all paths to tree
361
361
        # relative : it's cheaper to make a tree relative path an abspath
362
362
        # than to convert an abspath to tree relative, and it's cheaper to
363
363
        # perform the canonicalization in bulk.
364
364
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
365
365
            rf = _FastPath(filepath)
366
366
            # validate user parameters. Our recursive code avoids adding new files
367
 
            # that need such validation 
 
367
            # that need such validation
368
368
            if self.is_control_filename(rf.raw_path):
369
369
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
370
 
            
 
370
 
371
371
            abspath = self.abspath(rf.raw_path)
372
372
            kind = osutils.file_kind(abspath)
373
373
            if kind == 'directory':
378
378
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
379
379
            # ensure the named path is added, so that ignore rules in the later directory
380
380
            # walk dont skip it.
381
 
            # we dont have a parent ie known yet.: use the relatively slower inventory 
 
381
            # we dont have a parent ie known yet.: use the relatively slower inventory
382
382
            # probing method
383
383
            versioned = inv.has_filename(rf.raw_path)
384
384
            if versioned:
421
421
            if parent_ie is not None:
422
422
                versioned = directory.base_path in parent_ie.children
423
423
            else:
424
 
                # without the parent ie, use the relatively slower inventory 
 
424
                # without the parent ie, use the relatively slower inventory
425
425
                # probing method
426
426
                versioned = inv.has_filename(
427
427
                        self._fix_case_of_inventory_path(directory.raw_path))
445
445
                # mutter("%r is already versioned", abspath)
446
446
            elif sub_tree:
447
447
                # XXX: This is wrong; people *might* reasonably be trying to add
448
 
                # subtrees as subtrees.  This should probably only be done in formats 
 
448
                # subtrees as subtrees.  This should probably only be done in formats
449
449
                # which can represent subtrees, and even then perhaps only when
450
450
                # the user asked to add subtrees.  At the moment you can add them
451
451
                # specially through 'join --reference', which is perhaps
461
461
                    # must be present:
462
462
                    this_ie = parent_ie.children[directory.base_path]
463
463
                else:
464
 
                    # without the parent ie, use the relatively slower inventory 
 
464
                    # without the parent ie, use the relatively slower inventory
465
465
                    # probing method
466
466
                    this_id = inv.path2id(
467
467
                            self._fix_case_of_inventory_path(directory.raw_path))
471
471
                        this_ie = inv[this_id]
472
472
 
473
473
                for subf in sorted(os.listdir(abspath)):
474
 
                    # here we could use TreeDirectory rather than 
 
474
                    # here we could use TreeDirectory rather than
475
475
                    # string concatenation.
476
476
                    subp = osutils.pathjoin(directory.raw_path, subf)
477
 
                    # TODO: is_control_filename is very slow. Make it faster. 
478
 
                    # TreeDirectory.is_control_filename could also make this 
479
 
                    # faster - its impossible for a non root dir to have a 
 
477
                    # TODO: is_control_filename is very slow. Make it faster.
 
478
                    # TreeDirectory.is_control_filename could also make this
 
479
                    # faster - its impossible for a non root dir to have a
480
480
                    # control file.
481
481
                    if self.is_control_filename(subp):
482
482
                        mutter("skip control directory %r", subp)
540
540
 
541
541
 
542
542
class MutableTreeHooks(hooks.Hooks):
543
 
    """A dictionary mapping a hook name to a list of callables for mutabletree 
 
543
    """A dictionary mapping a hook name to a list of callables for mutabletree
544
544
    hooks.
545
545
    """
546
546