~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Martin Pool
  • Date: 2005-05-16 01:54:16 UTC
  • Revision ID: mbp@sourcefrog.net-20050516015416-fd816a5e09c0698b
- commit takes an optional caller-specified revision id

Show diffs side-by-side

added added

removed removed

Lines of Context:
33
33
from revision import Revision
34
34
from errors import bailout, BzrError
35
35
from textui import show_status
36
 
from diff import diff_trees
37
36
 
38
37
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
39
38
## TODO: Maybe include checks for common corruption of newlines, etc?
304
303
                         """Inventory for the working copy.""")
305
304
 
306
305
 
307
 
    def add(self, files, verbose=False):
 
306
    def add(self, files, verbose=False, ids=None):
308
307
        """Make files versioned.
309
308
 
310
309
        Note that the command line normally calls smart_add instead.
323
322
        TODO: Adding a directory should optionally recurse down and
324
323
               add all non-ignored children.  Perhaps do that in a
325
324
               higher-level method.
326
 
 
327
 
        >>> b = ScratchBranch(files=['foo'])
328
 
        >>> 'foo' in b.unknowns()
329
 
        True
330
 
        >>> b.show_status()
331
 
        ?       foo
332
 
        >>> b.add('foo')
333
 
        >>> 'foo' in b.unknowns()
334
 
        False
335
 
        >>> bool(b.inventory.path2id('foo'))
336
 
        True
337
 
        >>> b.show_status()
338
 
        A       foo
339
 
 
340
 
        >>> b.add('foo')
341
 
        Traceback (most recent call last):
342
 
        ...
343
 
        BzrError: ('foo is already versioned', [])
344
 
 
345
 
        >>> b.add(['nothere'])
346
 
        Traceback (most recent call last):
347
 
        BzrError: ('cannot add: not a regular file or directory: nothere', [])
348
325
        """
349
326
        self._need_writelock()
350
327
 
351
328
        # TODO: Re-adding a file that is removed in the working copy
352
329
        # should probably put it back with the previous ID.
353
330
        if isinstance(files, types.StringTypes):
 
331
            assert(ids is None or isinstance(ids, types.StringTypes))
354
332
            files = [files]
 
333
            if ids is not None:
 
334
                ids = [ids]
 
335
 
 
336
        if ids is None:
 
337
            ids = [None] * len(files)
 
338
        else:
 
339
            assert(len(ids) == len(files))
355
340
        
356
341
        inv = self.read_working_inventory()
357
 
        for f in files:
 
342
        for f,file_id in zip(files, ids):
358
343
            if is_control_file(f):
359
344
                bailout("cannot add control file %s" % quotefn(f))
360
345
 
374
359
            if kind != 'file' and kind != 'directory':
375
360
                bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
376
361
 
377
 
            file_id = gen_file_id(f)
 
362
            if file_id is None:
 
363
                file_id = gen_file_id(f)
378
364
            inv.add_path(f, kind=kind, file_id=file_id)
379
365
 
380
366
            if verbose:
403
389
 
404
390
        TODO: Refuse to remove modified files unless --force is given?
405
391
 
406
 
        >>> b = ScratchBranch(files=['foo'])
407
 
        >>> b.add('foo')
408
 
        >>> b.inventory.has_filename('foo')
409
 
        True
410
 
        >>> b.remove('foo')
411
 
        >>> b.working_tree().has_filename('foo')
412
 
        True
413
 
        >>> b.inventory.has_filename('foo')
414
 
        False
415
 
        
416
 
        >>> b = ScratchBranch(files=['foo'])
417
 
        >>> b.add('foo')
418
 
        >>> b.commit('one')
419
 
        >>> b.remove('foo')
420
 
        >>> b.commit('two')
421
 
        >>> b.inventory.has_filename('foo') 
422
 
        False
423
 
        >>> b.basis_tree().has_filename('foo') 
424
 
        False
425
 
        >>> b.working_tree().has_filename('foo') 
426
 
        True
427
 
 
428
392
        TODO: Do something useful with directories.
429
393
 
430
394
        TODO: Should this remove the text or not?  Tough call; not
459
423
 
460
424
        self._write_inventory(inv)
461
425
 
 
426
    def set_inventory(self, new_inventory_list):
 
427
        inv = Inventory()
 
428
        for path, file_id, parent, kind in new_inventory_list:
 
429
            name = os.path.basename(path)
 
430
            if name == "":
 
431
                continue
 
432
            inv.add(InventoryEntry(file_id, name, kind, parent))
 
433
        self._write_inventory(inv)
 
434
 
462
435
 
463
436
    def unknowns(self):
464
437
        """Return all unknown files.
479
452
        return self.working_tree().unknowns()
480
453
 
481
454
 
482
 
    def commit(self, message, timestamp=None, timezone=None,
483
 
               committer=None,
484
 
               verbose=False):
485
 
        """Commit working copy as a new revision.
486
 
        
487
 
        The basic approach is to add all the file texts into the
488
 
        store, then the inventory, then make a new revision pointing
489
 
        to that inventory and store that.
490
 
        
491
 
        This is not quite safe if the working copy changes during the
492
 
        commit; for the moment that is simply not allowed.  A better
493
 
        approach is to make a temporary copy of the files before
494
 
        computing their hashes, and then add those hashes in turn to
495
 
        the inventory.  This should mean at least that there are no
496
 
        broken hash pointers.  There is no way we can get a snapshot
497
 
        of the whole directory at an instant.  This would also have to
498
 
        be robust against files disappearing, moving, etc.  So the
499
 
        whole thing is a bit hard.
500
 
 
501
 
        timestamp -- if not None, seconds-since-epoch for a
502
 
             postdated/predated commit.
503
 
        """
504
 
        self._need_writelock()
505
 
 
506
 
        ## TODO: Show branch names
507
 
 
508
 
        # TODO: Don't commit if there are no changes, unless forced?
509
 
 
510
 
        # First walk over the working inventory; and both update that
511
 
        # and also build a new revision inventory.  The revision
512
 
        # inventory needs to hold the text-id, sha1 and size of the
513
 
        # actual file versions committed in the revision.  (These are
514
 
        # not present in the working inventory.)  We also need to
515
 
        # detect missing/deleted files, and remove them from the
516
 
        # working inventory.
517
 
 
518
 
        work_inv = self.read_working_inventory()
519
 
        inv = Inventory()
520
 
        basis = self.basis_tree()
521
 
        basis_inv = basis.inventory
522
 
        missing_ids = []
523
 
        for path, entry in work_inv.iter_entries():
524
 
            ## TODO: Cope with files that have gone missing.
525
 
 
526
 
            ## TODO: Check that the file kind has not changed from the previous
527
 
            ## revision of this file (if any).
528
 
 
529
 
            entry = entry.copy()
530
 
 
531
 
            p = self.abspath(path)
532
 
            file_id = entry.file_id
533
 
            mutter('commit prep file %s, id %r ' % (p, file_id))
534
 
 
535
 
            if not os.path.exists(p):
536
 
                mutter("    file is missing, removing from inventory")
537
 
                if verbose:
538
 
                    show_status('D', entry.kind, quotefn(path))
539
 
                missing_ids.append(file_id)
540
 
                continue
541
 
 
542
 
            # TODO: Handle files that have been deleted
543
 
 
544
 
            # TODO: Maybe a special case for empty files?  Seems a
545
 
            # waste to store them many times.
546
 
 
547
 
            inv.add(entry)
548
 
 
549
 
            if basis_inv.has_id(file_id):
550
 
                old_kind = basis_inv[file_id].kind
551
 
                if old_kind != entry.kind:
552
 
                    bailout("entry %r changed kind from %r to %r"
553
 
                            % (file_id, old_kind, entry.kind))
554
 
 
555
 
            if entry.kind == 'directory':
556
 
                if not isdir(p):
557
 
                    bailout("%s is entered as directory but not a directory" % quotefn(p))
558
 
            elif entry.kind == 'file':
559
 
                if not isfile(p):
560
 
                    bailout("%s is entered as file but is not a file" % quotefn(p))
561
 
 
562
 
                content = file(p, 'rb').read()
563
 
 
564
 
                entry.text_sha1 = sha_string(content)
565
 
                entry.text_size = len(content)
566
 
 
567
 
                old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
568
 
                if (old_ie
569
 
                    and (old_ie.text_size == entry.text_size)
570
 
                    and (old_ie.text_sha1 == entry.text_sha1)):
571
 
                    ## assert content == basis.get_file(file_id).read()
572
 
                    entry.text_id = basis_inv[file_id].text_id
573
 
                    mutter('    unchanged from previous text_id {%s}' %
574
 
                           entry.text_id)
575
 
                    
576
 
                else:
577
 
                    entry.text_id = gen_file_id(entry.name)
578
 
                    self.text_store.add(content, entry.text_id)
579
 
                    mutter('    stored with text_id {%s}' % entry.text_id)
580
 
                    if verbose:
581
 
                        if not old_ie:
582
 
                            state = 'A'
583
 
                        elif (old_ie.name == entry.name
584
 
                              and old_ie.parent_id == entry.parent_id):
585
 
                            state = 'M'
586
 
                        else:
587
 
                            state = 'R'
588
 
 
589
 
                        show_status(state, entry.kind, quotefn(path))
590
 
 
591
 
        for file_id in missing_ids:
592
 
            # have to do this later so we don't mess up the iterator.
593
 
            # since parents may be removed before their children we
594
 
            # have to test.
595
 
 
596
 
            # FIXME: There's probably a better way to do this; perhaps
597
 
            # the workingtree should know how to filter itself.
598
 
            if work_inv.has_id(file_id):
599
 
                del work_inv[file_id]
600
 
 
601
 
 
602
 
        inv_id = rev_id = _gen_revision_id(time.time())
603
 
        
604
 
        inv_tmp = tempfile.TemporaryFile()
605
 
        inv.write_xml(inv_tmp)
606
 
        inv_tmp.seek(0)
607
 
        self.inventory_store.add(inv_tmp, inv_id)
608
 
        mutter('new inventory_id is {%s}' % inv_id)
609
 
 
610
 
        self._write_inventory(work_inv)
611
 
 
612
 
        if timestamp == None:
613
 
            timestamp = time.time()
614
 
 
615
 
        if committer == None:
616
 
            committer = username()
617
 
 
618
 
        if timezone == None:
619
 
            timezone = local_time_offset()
620
 
 
621
 
        mutter("building commit log message")
622
 
        rev = Revision(timestamp=timestamp,
623
 
                       timezone=timezone,
624
 
                       committer=committer,
625
 
                       precursor = self.last_patch(),
626
 
                       message = message,
627
 
                       inventory_id=inv_id,
628
 
                       revision_id=rev_id)
629
 
 
630
 
        rev_tmp = tempfile.TemporaryFile()
631
 
        rev.write_xml(rev_tmp)
632
 
        rev_tmp.seek(0)
633
 
        self.revision_store.add(rev_tmp, rev_id)
634
 
        mutter("new revision_id is {%s}" % rev_id)
635
 
        
636
 
        ## XXX: Everything up to here can simply be orphaned if we abort
637
 
        ## the commit; it will leave junk files behind but that doesn't
638
 
        ## matter.
639
 
 
640
 
        ## TODO: Read back the just-generated changeset, and make sure it
641
 
        ## applies and recreates the right state.
642
 
 
643
 
        ## TODO: Also calculate and store the inventory SHA1
644
 
        mutter("committing patch r%d" % (self.revno() + 1))
645
 
 
646
 
 
647
 
        self.append_revision(rev_id)
648
 
        
649
 
        if verbose:
650
 
            note("commited r%d" % self.revno())
651
 
 
652
 
 
653
455
    def append_revision(self, revision_id):
654
456
        mutter("add {%s} to revision-history" % revision_id)
655
457
        rev_history = self.revision_history()
734
536
 
735
537
        That is equivalent to the number of revisions committed to
736
538
        this branch.
737
 
 
738
 
        >>> b = ScratchBranch()
739
 
        >>> b.revno()
740
 
        0
741
 
        >>> b.commit('no foo')
742
 
        >>> b.revno()
743
 
        1
744
539
        """
745
540
        return len(self.revision_history())
746
541
 
747
542
 
748
543
    def last_patch(self):
749
544
        """Return last patch hash, or None if no history.
750
 
 
751
 
        >>> ScratchBranch().last_patch() == None
752
 
        True
753
545
        """
754
546
        ph = self.revision_history()
755
547
        if ph:
756
548
            return ph[-1]
757
549
        else:
758
550
            return None
 
551
 
 
552
 
 
553
    def commit(self, *args, **kw):
 
554
        """Deprecated"""
 
555
        from bzrlib.commit import commit
 
556
        commit(self, *args, **kw)
759
557
        
760
558
 
761
559
    def lookup_revision(self, revno):
793
591
        """Return `Tree` object for last revision.
794
592
 
795
593
        If there are no revisions yet, return an `EmptyTree`.
796
 
 
797
 
        >>> b = ScratchBranch(files=['foo'])
798
 
        >>> b.basis_tree().has_filename('foo')
799
 
        False
800
 
        >>> b.working_tree().has_filename('foo')
801
 
        True
802
 
        >>> b.add('foo')
803
 
        >>> b.commit('add foo')
804
 
        >>> b.basis_tree().has_filename('foo')
805
 
        True
806
594
        """
807
595
        r = self.last_patch()
808
596
        if r == None:
989
777
 
990
778
 
991
779
 
992
 
def _gen_revision_id(when):
993
 
    """Return new revision-id."""
994
 
    s = '%s-%s-' % (user_email(), compact_date(when))
995
 
    s += hexlify(rand_bytes(8))
996
 
    return s
997
 
 
998
 
 
999
780
def gen_file_id(name):
1000
781
    """Return new file id.
1001
782