/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/weave.py

remove all trailing whitespace from bzr source

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/weave.py
1
 
# Copyright (C) 2005, 2009 Canonical Ltd
 
1
#! /usr/bin/python
 
2
 
 
3
# Copyright (C) 2005 Canonical Ltd
2
4
#
3
5
# This program is free software; you can redistribute it and/or modify
4
6
# it under the terms of the GNU General Public License as published by
12
14
#
13
15
# You should have received a copy of the GNU General Public License
14
16
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
18
 
17
19
# Author: Martin Pool <mbp@canonical.com>
18
20
 
69
71
from copy import copy
70
72
from cStringIO import StringIO
71
73
import os
 
74
import time
 
75
import warnings
72
76
 
73
77
from bzrlib.lazy_import import lazy_import
74
78
lazy_import(globals(), """
77
81
from bzrlib import (
78
82
    errors,
79
83
    osutils,
 
84
    progress,
80
85
    )
81
86
from bzrlib.errors import (WeaveError, WeaveFormatError, WeaveParentMismatch,
82
87
        RevisionAlreadyPresent,
83
88
        RevisionNotPresent,
84
89
        UnavailableRepresentation,
 
90
        WeaveRevisionAlreadyPresent,
 
91
        WeaveRevisionNotPresent,
85
92
        )
86
93
from bzrlib.osutils import dirname, sha, sha_strings, split_lines
87
94
import bzrlib.patiencediff
92
99
    AbsentContentFactory,
93
100
    adapter_registry,
94
101
    ContentFactory,
95
 
    sort_groupcompress,
96
102
    VersionedFile,
97
103
    )
98
104
from bzrlib.weavefile import _read_weave_v5, write_weave_v5
315
321
            new_versions = tsort.topo_sort(parents)
316
322
            new_versions.extend(set(versions).difference(set(parents)))
317
323
            versions = new_versions
318
 
        elif ordering == 'groupcompress':
319
 
            parents = self.get_parent_map(versions)
320
 
            new_versions = sort_groupcompress(parents)
321
 
            new_versions.extend(set(versions).difference(set(parents)))
322
 
            versions = new_versions
323
324
        for version in versions:
324
325
            if version in self:
325
326
                yield WeaveContentFactory(version, self)
371
372
                    adapter_factory = adapter_registry.get(adapter_key)
372
373
                    adapter = adapter_factory(self)
373
374
                    adapters[adapter_key] = adapter
374
 
                lines = split_lines(adapter.get_bytes(record))
 
375
                lines = split_lines(adapter.get_bytes(
 
376
                    record, record.get_bytes_as(record.storage_kind)))
375
377
                try:
376
378
                    self.add_lines(record.key[0], parents, lines)
377
379
                except RevisionAlreadyPresent:
403
405
        version_id
404
406
            Symbolic name for this version.
405
407
            (Typically the revision-id of the revision that added it.)
406
 
            If None, a name will be allocated based on the hash. (sha1:SHAHASH)
407
408
 
408
409
        parents
409
410
            List or set of direct parent version numbers.
419
420
            sha1 = sha_strings(lines)
420
421
        if sha1 == nostore_sha:
421
422
            raise errors.ExistingContent
422
 
        if version_id is None:
423
 
            version_id = "sha1:" + sha1
424
423
        if version_id in self._name_map:
425
424
            return self._check_repeated_add(version_id, parents, lines, sha1)
426
425
 
577
576
            version_ids = self.versions()
578
577
        version_ids = set(version_ids)
579
578
        for lineno, inserted, deletes, line in self._walk_internal(version_ids):
580
 
            if inserted not in version_ids: continue
 
579
            # if inserted not in version_ids then it was inserted before the
 
580
            # versions we care about, but because weaves cannot represent ghosts
 
581
            # properly, we do not filter down to that
 
582
            # if inserted not in version_ids: continue
581
583
            if line[-1] != '\n':
582
584
                yield line + '\n', inserted
583
585
            else:
968
970
        super(WeaveFile, self).insert_record_stream(stream)
969
971
        self._save()
970
972
 
 
973
    @deprecated_method(one_five)
 
974
    def join(self, other, pb=None, msg=None, version_ids=None,
 
975
             ignore_missing=False):
 
976
        """Join other into self and save."""
 
977
        super(WeaveFile, self).join(other, pb, msg, version_ids, ignore_missing)
 
978
        self._save()
 
979
 
971
980
 
972
981
def _reweave(wa, wb, pb=None, msg=None):
973
982
    """Combine two weaves and return the result.
1018
1027
        wr._add(name, lines, [wr._lookup(i) for i in combined_parents[name]])
1019
1028
    return wr
1020
1029
 
1021
 
 
1022
1030
def _reweave_parent_graphs(wa, wb):
1023
1031
    """Return combined parent ancestry for two weaves.
1024
1032
 
1029
1037
            p = combined.setdefault(name, set())
1030
1038
            p.update(map(weave._idx_to_name, weave._parents[idx]))
1031
1039
    return combined
 
1040
 
 
1041
 
 
1042
def weave_toc(w):
 
1043
    """Show the weave's table-of-contents"""
 
1044
    print '%6s %50s %10s %10s' % ('ver', 'name', 'sha1', 'parents')
 
1045
    for i in (6, 50, 10, 10):
 
1046
        print '-' * i,
 
1047
    print
 
1048
    for i in range(w.num_versions()):
 
1049
        sha1 = w._sha1s[i]
 
1050
        name = w._names[i]
 
1051
        parent_str = ' '.join(map(str, w._parents[i]))
 
1052
        print '%6d %-50.50s %10.10s %s' % (i, name, sha1, parent_str)
 
1053
 
 
1054
 
 
1055
 
 
1056
def weave_stats(weave_file, pb):
 
1057
    from bzrlib.weavefile import read_weave
 
1058
 
 
1059
    wf = file(weave_file, 'rb')
 
1060
    w = read_weave(wf)
 
1061
    # FIXME: doesn't work on pipes
 
1062
    weave_size = wf.tell()
 
1063
 
 
1064
    total = 0
 
1065
    vers = len(w)
 
1066
    for i in range(vers):
 
1067
        pb.update('checking sizes', i, vers)
 
1068
        for origin, lineno, line in w._extract([i]):
 
1069
            total += len(line)
 
1070
 
 
1071
    pb.clear()
 
1072
 
 
1073
    print 'versions          %9d' % vers
 
1074
    print 'weave file        %9d bytes' % weave_size
 
1075
    print 'total contents    %9d bytes' % total
 
1076
    print 'compression ratio %9.2fx' % (float(total) / float(weave_size))
 
1077
    if vers:
 
1078
        avg = total/vers
 
1079
        print 'average size      %9d bytes' % avg
 
1080
        print 'relative size     %9.2fx' % (float(weave_size) / float(avg))
 
1081
 
 
1082
 
 
1083
def usage():
 
1084
    print """bzr weave tool
 
1085
 
 
1086
Experimental tool for weave algorithm.
 
1087
 
 
1088
usage:
 
1089
    weave init WEAVEFILE
 
1090
        Create an empty weave file
 
1091
    weave get WEAVEFILE VERSION
 
1092
        Write out specified version.
 
1093
    weave check WEAVEFILE
 
1094
        Check consistency of all versions.
 
1095
    weave toc WEAVEFILE
 
1096
        Display table of contents.
 
1097
    weave add WEAVEFILE NAME [BASE...] < NEWTEXT
 
1098
        Add NEWTEXT, with specified parent versions.
 
1099
    weave annotate WEAVEFILE VERSION
 
1100
        Display origin of each line.
 
1101
    weave merge WEAVEFILE VERSION1 VERSION2 > OUT
 
1102
        Auto-merge two versions and display conflicts.
 
1103
    weave diff WEAVEFILE VERSION1 VERSION2
 
1104
        Show differences between two versions.
 
1105
 
 
1106
example:
 
1107
 
 
1108
    % weave init foo.weave
 
1109
    % vi foo.txt
 
1110
    % weave add foo.weave ver0 < foo.txt
 
1111
    added version 0
 
1112
 
 
1113
    (create updated version)
 
1114
    % vi foo.txt
 
1115
    % weave get foo.weave 0 | diff -u - foo.txt
 
1116
    % weave add foo.weave ver1 0 < foo.txt
 
1117
    added version 1
 
1118
 
 
1119
    % weave get foo.weave 0 > foo.txt       (create forked version)
 
1120
    % vi foo.txt
 
1121
    % weave add foo.weave ver2 0 < foo.txt
 
1122
    added version 2
 
1123
 
 
1124
    % weave merge foo.weave 1 2 > foo.txt   (merge them)
 
1125
    % vi foo.txt                            (resolve conflicts)
 
1126
    % weave add foo.weave merged 1 2 < foo.txt     (commit merged version)
 
1127
 
 
1128
"""
 
1129
 
 
1130
 
 
1131
 
 
1132
def main(argv):
 
1133
    import sys
 
1134
    import os
 
1135
    try:
 
1136
        import bzrlib
 
1137
    except ImportError:
 
1138
        # in case we're run directly from the subdirectory
 
1139
        sys.path.append('..')
 
1140
        import bzrlib
 
1141
    from bzrlib.weavefile import write_weave, read_weave
 
1142
    from bzrlib.progress import ProgressBar
 
1143
 
 
1144
    try:
 
1145
        import psyco
 
1146
        psyco.full()
 
1147
    except ImportError:
 
1148
        pass
 
1149
 
 
1150
    if len(argv) < 2:
 
1151
        usage()
 
1152
        return 0
 
1153
 
 
1154
    cmd = argv[1]
 
1155
 
 
1156
    def readit():
 
1157
        return read_weave(file(argv[2], 'rb'))
 
1158
 
 
1159
    if cmd == 'help':
 
1160
        usage()
 
1161
    elif cmd == 'add':
 
1162
        w = readit()
 
1163
        # at the moment, based on everything in the file
 
1164
        name = argv[3]
 
1165
        parents = map(int, argv[4:])
 
1166
        lines = sys.stdin.readlines()
 
1167
        ver = w.add(name, parents, lines)
 
1168
        write_weave(w, file(argv[2], 'wb'))
 
1169
        print 'added version %r %d' % (name, ver)
 
1170
    elif cmd == 'init':
 
1171
        fn = argv[2]
 
1172
        if os.path.exists(fn):
 
1173
            raise IOError("file exists")
 
1174
        w = Weave()
 
1175
        write_weave(w, file(fn, 'wb'))
 
1176
    elif cmd == 'get': # get one version
 
1177
        w = readit()
 
1178
        sys.stdout.writelines(w.get_iter(int(argv[3])))
 
1179
 
 
1180
    elif cmd == 'diff':
 
1181
        w = readit()
 
1182
        fn = argv[2]
 
1183
        v1, v2 = map(int, argv[3:5])
 
1184
        lines1 = w.get(v1)
 
1185
        lines2 = w.get(v2)
 
1186
        diff_gen = bzrlib.patiencediff.unified_diff(lines1, lines2,
 
1187
                                '%s version %d' % (fn, v1),
 
1188
                                '%s version %d' % (fn, v2))
 
1189
        sys.stdout.writelines(diff_gen)
 
1190
 
 
1191
    elif cmd == 'annotate':
 
1192
        w = readit()
 
1193
        # newline is added to all lines regardless; too hard to get
 
1194
        # reasonable formatting otherwise
 
1195
        lasto = None
 
1196
        for origin, text in w.annotate(int(argv[3])):
 
1197
            text = text.rstrip('\r\n')
 
1198
            if origin == lasto:
 
1199
                print '      | %s' % (text)
 
1200
            else:
 
1201
                print '%5d | %s' % (origin, text)
 
1202
                lasto = origin
 
1203
 
 
1204
    elif cmd == 'toc':
 
1205
        weave_toc(readit())
 
1206
 
 
1207
    elif cmd == 'stats':
 
1208
        weave_stats(argv[2], ProgressBar())
 
1209
 
 
1210
    elif cmd == 'check':
 
1211
        w = readit()
 
1212
        pb = ProgressBar()
 
1213
        w.check(pb)
 
1214
        pb.clear()
 
1215
        print '%d versions ok' % w.num_versions()
 
1216
 
 
1217
    elif cmd == 'inclusions':
 
1218
        w = readit()
 
1219
        print ' '.join(map(str, w.inclusions([int(argv[3])])))
 
1220
 
 
1221
    elif cmd == 'parents':
 
1222
        w = readit()
 
1223
        print ' '.join(map(str, w._parents[int(argv[3])]))
 
1224
 
 
1225
    elif cmd == 'plan-merge':
 
1226
        # replaced by 'bzr weave-plan-merge'
 
1227
        w = readit()
 
1228
        for state, line in w.plan_merge(int(argv[3]), int(argv[4])):
 
1229
            if line:
 
1230
                print '%14s | %s' % (state, line),
 
1231
    elif cmd == 'merge':
 
1232
        # replaced by 'bzr weave-merge-text'
 
1233
        w = readit()
 
1234
        p = w.plan_merge(int(argv[3]), int(argv[4]))
 
1235
        sys.stdout.writelines(w.weave_merge(p))
 
1236
    else:
 
1237
        raise ValueError('unknown command %r' % cmd)
 
1238
 
 
1239
 
 
1240
if __name__ == '__main__':
 
1241
    import sys
 
1242
    sys.exit(main(sys.argv))