← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: aaron.bentley at utoronto
  • Date: 2005-09-04 02:59:56 UTC
  • mfrom: (1172)
  • mto: (1185.3.4)
  • mto: This revision was merged to the branch mainline in revision 1178.
  • Revision ID: aaron.bentley@utoronto.ca-20050904025956-776ba4f07de97700
Merged mpool's latest changes (~0.0.7)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
404
404
                         """Inventory for the working copy.""")
405
405
 
406
406
 
407
 
    def add(self, files, verbose=False, ids=None):
 
407
    def add(self, files, ids=None):
408
408
        """Make files versioned.
409
409
 
410
 
        Note that the command line normally calls smart_add instead.
 
410
        Note that the command line normally calls smart_add instead,
 
411
        which can automatically recurse.
411
412
 
412
413
        This puts the files in the Added state, so that they will be
413
414
        recorded by the next commit.
423
424
        TODO: Perhaps have an option to add the ids even if the files do
424
425
              not (yet) exist.
425
426
 
426
 
        TODO: Perhaps return the ids of the files?  But then again it
427
 
              is easy to retrieve them if they're needed.
428
 
 
429
 
        TODO: Adding a directory should optionally recurse down and
430
 
              add all non-ignored children.  Perhaps do that in a
431
 
              higher-level method.
 
427
        TODO: Perhaps yield the ids and paths as they're added.
432
428
        """
433
429
        # TODO: Re-adding a file that is removed in the working copy
434
430
        # should probably put it back with the previous ID.
470
466
                    file_id = gen_file_id(f)
471
467
                inv.add_path(f, kind=kind, file_id=file_id)
472
468
 
473
 
                if verbose:
474
 
                    print 'added', quotefn(f)
475
 
 
476
469
                mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
477
470
 
478
471
            self._write_inventory(inv)
1153
1146
 
1154
1147
            inv.rename(file_id, to_dir_id, to_tail)
1155
1148
 
1156
 
            print "%s => %s" % (from_rel, to_rel)
1157
 
 
1158
1149
            from_abs = self.abspath(from_rel)
1159
1150
            to_abs = self.abspath(to_rel)
1160
1151
            try:
1179
1170
 
1180
1171
        Note that to_name is only the last component of the new name;
1181
1172
        this doesn't change the directory.
 
1173
 
 
1174
        This returns a list of (from_path, to_path) pairs for each
 
1175
        entry that is moved.
1182
1176
        """
 
1177
        result = []
1183
1178
        self.lock_write()
1184
1179
        try:
1185
1180
            ## TODO: Option to move IDs only
1220
1215
            for f in from_paths:
1221
1216
                name_tail = splitpath(f)[-1]
1222
1217
                dest_path = appendpath(to_name, name_tail)
1223
 
                print "%s => %s" % (f, dest_path)
 
1218
                result.append((f, dest_path))
1224
1219
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
1225
1220
                try:
1226
1221
                    os.rename(self.abspath(f), self.abspath(dest_path))
1232
1227
        finally:
1233
1228
            self.unlock()
1234
1229
 
 
1230
        return result
 
1231
 
1235
1232
 
1236
1233
    def revert(self, filenames, old_tree=None, backups=True):
1237
1234
        """Restore selected files to the versions from a previous tree.
1319
1316
            self.unlock()
1320
1317
 
1321
1318
 
 
1319
    def get_parent(self):
 
1320
        """Return the parent location of the branch.
 
1321
 
 
1322
        This is the default location for push/pull/missing.  The usual
 
1323
        pattern is that the user can override it by specifying a
 
1324
        location.
 
1325
        """
 
1326
        import errno
 
1327
        _locs = ['parent', 'pull', 'x-pull']
 
1328
        for l in _locs:
 
1329
            try:
 
1330
                return self.controlfile(l, 'r').read().strip('\n')
 
1331
            except IOError, e:
 
1332
                if e.errno != errno.ENOENT:
 
1333
                    raise
 
1334
        return None
 
1335
 
 
1336
 
 
1337
    def set_parent(self, url):
 
1338
        # TODO: Maybe delete old location files?
 
1339
        from bzrlib.atomicfile import AtomicFile
 
1340
        self.lock_write()
 
1341
        try:
 
1342
            f = AtomicFile(self.controlfilename('parent'))
 
1343
            try:
 
1344
                f.write(url + '\n')
 
1345
                f.commit()
 
1346
            finally:
 
1347
                f.close()
 
1348
        finally:
 
1349
            self.unlock()
 
1350
 
 
1351
        
 
1352
 
1322
1353
 
1323
1354
class ScratchBranch(Branch):
1324
1355
    """Special test class: a branch that cleans up after itself.
1366
1397
        os.rmdir(base)
1367
1398
        copytree(self.base, base, symlinks=True)
1368
1399
        return ScratchBranch(base=base)
 
1400
 
 
1401
 
1369
1402
        
1370
1403
    def __del__(self):
1371
1404
        self.destroy()
1454
1487
def copy_branch(branch_from, to_location, revision=None):
1455
1488
    """Copy branch_from into the existing directory to_location.
1456
1489
 
1457
 
    If revision is not None, the head of the new branch will be revision.
 
1490
    revision
 
1491
        If not None, only revisions up to this point will be copied.
 
1492
        The head of the new branch will be that revision.
 
1493
 
 
1494
    to_location
 
1495
        The name of a local directory that exists but is empty.
1458
1496
    """
1459
1497
    from bzrlib.merge import merge
1460
1498
    from bzrlib.branch import Branch
 
1499
 
 
1500
    assert isinstance(branch_from, Branch)
 
1501
    assert isinstance(to_location, basestring)
 
1502
    
1461
1503
    br_to = Branch(to_location, init=True)
1462
1504
    br_to.set_root_id(branch_from.get_root_id())
1463
1505
    if revision is None:
1467
1509
    br_to.update_revisions(branch_from, stop_revision=revno)
1468
1510
    merge((to_location, -1), (to_location, 0), this_dir=to_location,
1469
1511
          check_clean=False, ignore_zero=True)
 
1512
    
1470
1513
    from_location = pull_loc(branch_from)
1471
 
    br_to.controlfile("x-pull", "wb").write(from_location + "\n")
 
1514
    br_to.set_parent(pull_loc(branch_from))
1472
1515