← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/dirstate.py

  • Committer: Martin Pool
  • Date: 2008-04-24 07:22:53 UTC
  • mto: This revision was merged to the branch mainline in revision 3415.
  • Revision ID: mbp@sourcefrog.net-20080424072253-opmjij7xfy38w27f
Remove every assert statement from bzrlib!

Depending on the context they are:

 * turned into an explicit if/raise of either AssertionError 
   or something more specific -- particularly where they protect
   programming interfaces, complex invariants, or data file integrity
 * removed, if they're redundant with a later check, not protecting
   a meaningful invariant
 * turned into a selftest method on tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/dirstate.py
393
393
        # faster than three separate encodes.
394
394
        utf8path = (dirname + '/' + basename).strip('/').encode('utf8')
395
395
        dirname, basename = osutils.split(utf8path)
396
 
        assert file_id.__class__ == str, \
397
 
            "must be a utf8 file_id not %s" % (type(file_id))
 
396
        if file_id.__class__ != str:
 
397
            raise AssertionError(
 
398
                "must be a utf8 file_id not %s" % (type(file_id), ))
398
399
        # Make sure the file_id does not exist in this tree
399
400
        file_id_entry = self._get_entry(0, fileid_utf8=file_id)
400
401
        if file_id_entry != (None, None):
456
457
        if not present:
457
458
            block.insert(entry_index, entry_data)
458
459
        else:
459
 
            assert block[entry_index][1][0][0] == 'a', " %r(%r) already added" % (basename, file_id)
 
460
            if block[entry_index][1][0][0] != 'a':
 
461
                raise AssertionError(" %r(%r) already added" % (basename, file_id))
460
462
            block[entry_index][1][0] = entry_data[1][0]
461
463
 
462
464
        if kind == 'directory':
481
483
        # If _dirblock_state was in memory, we should just return info from
482
484
        # there, this function is only meant to handle when we want to read
483
485
        # part of the disk.
484
 
        assert self._dirblock_state == DirState.NOT_IN_MEMORY
 
486
        if self._dirblock_state != DirState.NOT_IN_MEMORY:
 
487
            raise AssertionError("bad dirblock state %r" % self._dirblock_state)
485
488
 
486
489
        # The disk representation is generally info + '\0\n\0' at the end. But
487
490
        # for bisecting, it is easier to treat this as '\0' + info + '\0\n'
673
676
        # If _dirblock_state was in memory, we should just return info from
674
677
        # there, this function is only meant to handle when we want to read
675
678
        # part of the disk.
676
 
        assert self._dirblock_state == DirState.NOT_IN_MEMORY
677
 
 
 
679
        if self._dirblock_state != DirState.NOT_IN_MEMORY:
 
680
            raise AssertionError("bad dirblock state %r" % self._dirblock_state)
678
681
        # The disk representation is generally info + '\0\n\0' at the end. But
679
682
        # for bisecting, it is easier to treat this as '\0' + info + '\0\n'
680
683
        # Because it means we can sync on the '\n'
967
970
        # the basename of the directory must be the end of its full name.
968
971
        if not (parent_block_index == -1 and
969
972
            parent_block_index == -1 and dirname == ''):
970
 
            assert dirname.endswith(
971
 
                self._dirblocks[parent_block_index][1][parent_row_index][0][1])
 
973
            if not dirname.endswith(
 
974
                    self._dirblocks[parent_block_index][1][parent_row_index][0][1]):
 
975
                raise AssertionError("bad dirname %r" % dirname)
972
976
        block_index, present = self._find_block_index_from_key((dirname, '', ''))
973
977
        if not present:
974
978
            ## In future, when doing partial parsing, this should load and 
986
990
            to prevent unneeded overhead when callers have a sorted list already.
987
991
        :return: Nothing.
988
992
        """
989
 
        assert new_entries[0][0][0:2] == ('', ''), \
990
 
            "Missing root row %r" % (new_entries[0][0],)
 
993
        if new_entries[0][0][0:2] != ('', ''):
 
994
            raise AssertionError(
 
995
                "Missing root row %r" % (new_entries[0][0],))
991
996
        # The two blocks here are deliberate: the root block and the 
992
997
        # contents-of-root block.
993
998
        self._dirblocks = [('', []), ('', [])]
1015
1020
        # The above loop leaves the "root block" entries mixed with the
1016
1021
        # "contents-of-root block". But we don't want an if check on
1017
1022
        # all entries, so instead we just fix it up here.
1018
 
        assert self._dirblocks[1] == ('', [])
 
1023
        if self._dirblocks[1] != ('', []):
 
1024
            raise ValueError("bad dirblock start %r" % (self._dirblocks[1],))
1019
1025
        root_block = []
1020
1026
        contents_of_root_block = []
1021
1027
        for entry in self._dirblocks[0][1]:
1175
1181
        self._read_dirblocks_if_needed()
1176
1182
        insertions = {}
1177
1183
        removals = {}
1178
 
        for old_path, new_path, file_id, inv_entry in sorted(delta,
1179
 
                                                             reverse=True):
1180
 
            assert file_id not in insertions
1181
 
            assert file_id not in removals
 
1184
        for old_path, new_path, file_id, inv_entry in sorted(delta, reverse=True):
 
1185
            if (file_id in insertions) or (file_id in removals):
 
1186
                raise AssertionError("repeated file id in delta %r" % (file_id,))
1182
1187
            if old_path is not None:
1183
1188
                old_path = old_path.encode('utf-8')
1184
1189
                removals[file_id] = old_path
1315
1320
                    if new_path_utf8:
1316
1321
                        target_path = new_path_utf8 + source_path[len(old_path):]
1317
1322
                    else:
1318
 
                        assert len(old_path) > 0, ("cannot rename directory to"
1319
 
                                                   " itself")
 
1323
                        if old_path == '':
 
1324
                            raise AssertionError("cannot rename directory to"
 
1325
                                " itself")
1320
1326
                        target_path = source_path[len(old_path) + 1:]
1321
1327
                    adds.append((None, target_path, entry[0][2], entry[1][1], False))
1322
1328
                    deletes.append(
1359
1365
        # their children, so we can process it linearly.
1360
1366
        absent = 'ar'
1361
1367
        for old_path, new_path, file_id, new_details, real_add in adds:
1362
 
            assert old_path is None
1363
1368
            # the entry for this file_id must be in tree 0.
1364
1369
            entry = self._get_entry(0, file_id, new_path)
1365
1370
            if entry[0] is None or entry[0][2] != file_id:
1384
1389
        """
1385
1390
        absent = 'ar'
1386
1391
        for old_path, new_path, file_id, new_details in changes:
1387
 
            assert old_path == new_path
1388
1392
            # the entry for this file_id must be in tree 0.
1389
1393
            entry = self._get_entry(0, file_id, new_path)
1390
1394
            if entry[0] is None or entry[0][2] != file_id:
1412
1416
        """
1413
1417
        null = DirState.NULL_PARENT_DETAILS
1414
1418
        for old_path, new_path, file_id, _, real_delete in deletes:
1415
 
            if real_delete:
1416
 
                assert new_path is None
1417
 
            else:
1418
 
                assert new_path is not None
 
1419
            if real_delete != (new_path is None):
 
1420
                raise AssertionError("bad delete delta")
1419
1421
            # the entry for this file_id must be in tree 1.
1420
1422
            dirname, basename = osutils.split(old_path)
1421
1423
            block_index, entry_index, dir_present, file_present = \
1736
1738
        """
1737
1739
        self._read_dirblocks_if_needed()
1738
1740
        if path_utf8 is not None:
1739
 
            assert path_utf8.__class__ == str, ('path_utf8 is not a str: %s %s'
1740
 
                % (type(path_utf8), path_utf8))
 
1741
            if not isinstance(path_utf8, str):
 
1742
                raise AssertionError('path_utf8 is not a str: %s %s'
 
1743
                    % (type(path_utf8), path_utf8))
1741
1744
            # path lookups are faster
1742
1745
            dirname, basename = osutils.split(path_utf8)
1743
1746
            block_index, entry_index, dir_present, file_present = \
1745
1748
            if not file_present:
1746
1749
                return None, None
1747
1750
            entry = self._dirblocks[block_index][1][entry_index]
1748
 
            assert entry[0][2] and entry[1][tree_index][0] not in ('a', 'r'), 'unversioned entry?!?!'
 
1751
            if not (entry[0][2] and entry[1][tree_index][0] not in ('a', 'r')):
 
1752
                raise AssertionError('unversioned entry?')
1749
1753
            if fileid_utf8:
1750
1754
                if entry[0][2] != fileid_utf8:
1751
1755
                    self._changes_aborted = True
1753
1757
                                          ' tree_index, file_id and path')
1754
1758
            return entry
1755
1759
        else:
1756
 
            assert fileid_utf8 is not None
1757
1760
            possible_keys = self._get_id_index().get(fileid_utf8, None)
1758
1761
            if not possible_keys:
1759
1762
                return None, None
1778
1781
                    if entry[1][tree_index][0] == 'a':
1779
1782
                        # there is no home for this entry in this tree
1780
1783
                        return None, None
1781
 
                    assert entry[1][tree_index][0] == 'r', \
1782
 
                        "entry %r has invalid minikind %r for tree %r" \
1783
 
                        % (entry,
1784
 
                           entry[1][tree_index][0],
1785
 
                           tree_index)
 
1784
                    if entry[1][tree_index][0] != 'r':
 
1785
                        raise AssertionError(
 
1786
                            "entry %r has invalid minikind %r for tree %r" \
 
1787
                            % (entry,
 
1788
                               entry[1][tree_index][0],
 
1789
                               tree_index))
1786
1790
                    real_path = entry[1][tree_index][1]
1787
1791
                    return self._get_entry(tree_index, fileid_utf8=fileid_utf8,
1788
1792
                        path_utf8=real_path)
1831
1835
        kind = inv_entry.kind
1832
1836
        minikind = DirState._kind_to_minikind[kind]
1833
1837
        tree_data = inv_entry.revision
1834
 
        assert tree_data, 'empty revision for the inv_entry %s.' % \
1835
 
            inv_entry.file_id
1836
1838
        if kind == 'directory':
1837
1839
            fingerprint = ''
1838
1840
            size = 0
1971
1973
        parent_line = self._state_file.readline()
1972
1974
        info = parent_line.split('\0')
1973
1975
        num_parents = int(info[0])
1974
 
        assert num_parents == len(info)-2, 'incorrect parent info line'
1975
1976
        self._parents = info[1:-1]
1976
 
 
1977
1977
        ghost_line = self._state_file.readline()
1978
1978
        info = ghost_line.split('\0')
1979
1979
        num_ghosts = int(info[1])
1980
 
        assert num_ghosts == len(info)-3, 'incorrect ghost info line'
1981
1980
        self._ghosts = info[2:-1]
1982
1981
        self._header_state = DirState.IN_MEMORY_UNMODIFIED
1983
1982
        self._end_of_header = self._state_file.tell()
2000
1999
        and their ids. Followed by a newline.
2001
2000
        """
2002
2001
        header = self._state_file.readline()
2003
 
        assert header == DirState.HEADER_FORMAT_3, \
2004
 
            'invalid header line: %r' % (header,)
 
2002
        if header != DirState.HEADER_FORMAT_3:
 
2003
            raise errors.BzrError(
 
2004
                'invalid header line: %r' % (header,))
2005
2005
        crc_line = self._state_file.readline()
2006
 
        assert crc_line.startswith('crc32: '), 'missing crc32 checksum'
 
2006
        if not crc_line.startswith('crc32: '):
 
2007
            raise errors.BzrError('missing crc32 checksum: %r' % crc_line)
2007
2008
        self.crc_expected = int(crc_line[len('crc32: '):-1])
2008
2009
        num_entries_line = self._state_file.readline()
2009
 
        assert num_entries_line.startswith('num_entries: '), 'missing num_entries line'
 
2010
        if not num_entries_line.startswith('num_entries: '):
 
2011
            raise errors.BzrError('missing num_entries line')
2010
2012
        self._num_entries = int(num_entries_line[len('num_entries: '):-1])
2011
2013
 
2012
2014
    def sha1_from_stat(self, path, stat_result, _pack_stat=pack_stat):
2100
2102
        :param new_id: The new id to assign to the path. This must be a utf8
2101
2103
            file id (not unicode, and not None).
2102
2104
        """
2103
 
        assert new_id.__class__ == str, \
2104
 
            "path_id %r is not a plain string" % (new_id,)
2105
2105
        self._read_dirblocks_if_needed()
2106
2106
        if len(path):
2107
2107
            # TODO: logic not written
2403
2403
            # Remove it, its meaningless.
2404
2404
            block = self._find_block(current_old[0])
2405
2405
            entry_index, present = self._find_entry_index(current_old[0], block[1])
2406
 
            assert present, 'could not find entry for %s' % (current_old,)
 
2406
            if not present:
 
2407
                raise AssertionError('could not find entry for %s' % (current_old,))
2407
2408
            block[1].pop(entry_index)
2408
2409
            # if we have an id_index in use, remove this key from it for this id.
2409
2410
            if self._id_index is not None:
2415
2416
        for update_key in all_remaining_keys:
2416
2417
            update_block_index, present = \
2417
2418
                self._find_block_index_from_key(update_key)
2418
 
            assert present, 'could not find block for %s' % (update_key,)
 
2419
            if not present:
 
2420
                raise AssertionError('could not find block for %s' % (update_key,))
2419
2421
            update_entry_index, present = \
2420
2422
                self._find_entry_index(update_key, self._dirblocks[update_block_index][1])
2421
 
            assert present, 'could not find entry for %s' % (update_key,)
 
2423
            if not present:
 
2424
                raise AssertionError('could not find entry for %s' % (update_key,))
2422
2425
            update_tree_details = self._dirblocks[update_block_index][1][update_entry_index][1]
2423
2426
            # it must not be absent at the moment
2424
 
            assert update_tree_details[0][0] != 'a' # absent
 
2427
            if update_tree_details[0][0] == 'a': # absent
 
2428
                raise AssertionError('bad row %r' % (update_tree_details,))
2425
2429
            update_tree_details[0] = DirState.NULL_PARENT_DETAILS
2426
2430
        self._dirblock_state = DirState.IN_MEMORY_MODIFIED
2427
2431
        return last_reference
2475
2479
                    # the test for existing kinds is different: this can be
2476
2480
                    # factored out to a helper though.
2477
2481
                    other_block_index, present = self._find_block_index_from_key(other_key)
2478
 
                    assert present, 'could not find block for %s' % (other_key,)
 
2482
                    if not present:
 
2483
                        raise AssertionError('could not find block for %s' % (other_key,))
2479
2484
                    other_entry_index, present = self._find_entry_index(other_key,
2480
2485
                                            self._dirblocks[other_block_index][1])
2481
 
                    assert present, 'could not find entry for %s' % (other_key,)
2482
 
                    assert path_utf8 is not None
 
2486
                    if not present:
 
2487
                        raise AssertionError('could not find entry for %s' % (other_key,))
 
2488
                    if path_utf8 is None:
 
2489
                        raise AssertionError('no path')
2483
2490
                    self._dirblocks[other_block_index][1][other_entry_index][1][0] = \
2484
2491
                        ('r', path_utf8, 0, False, '')
2485
2492
 
2491
2498
                    # records.
2492
2499
                    update_block_index, present = \
2493
2500
                        self._find_block_index_from_key(other_key)
2494
 
                    assert present, 'could not find block for %s' % (other_key,)
 
2501
                    if not present:
 
2502
                        raise AssertionError('could not find block for %s' % (other_key,))
2495
2503
                    update_entry_index, present = \
2496
2504
                        self._find_entry_index(other_key, self._dirblocks[update_block_index][1])
2497
 
                    assert present, 'could not find entry for %s' % (other_key,)
 
2505
                    if not present:
 
2506
                        raise AssertionError('could not find entry for %s' % (other_key,))
2498
2507
                    update_details = self._dirblocks[update_block_index][1][update_entry_index][1][lookup_index]
2499
2508
                    if update_details[0] in 'ar': # relocated, absent
2500
2509
                        # its a pointer or absent in lookup_index's tree, use
2518
2527
            # we may have passed entries in the state with this file id already
2519
2528
            # that were absent - where parent entries are - and they need to be
2520
2529
            # converted to relocated.
2521
 
            assert path_utf8 is not None
 
2530
            if path_utf8 is None:
 
2531
                raise AssertionError('no path')
2522
2532
            for entry_key in id_index.setdefault(key[2], set()):
2523
2533
                # TODO:PROFILING: It might be faster to just update
2524
2534
                # rather than checking if we need to, and then overwrite
2529
2539
                    # This is the vertical axis in the matrix, all pointing
2530
2540
                    # to the real path.
2531
2541
                    block_index, present = self._find_block_index_from_key(entry_key)
2532
 
                    assert present
 
2542
                    if not present:
 
2543
                        raise AssertionError('not present: %r', entry_key)
2533
2544
                    entry_index, present = self._find_entry_index(entry_key, self._dirblocks[block_index][1])
2534
 
                    assert present
 
2545
                    if not present:
 
2546
                        raise AssertionError('not present: %r', entry_key)
2535
2547
                    self._dirblocks[block_index][1][entry_index][1][0] = \
2536
2548
                        ('r', path_utf8, 0, False, '')
2537
2549
        # add a containing dirblock if needed.