1
=== modified file 'commands.py'
2
--- commands.py	2010-12-26 14:29:55 +0000
3
+++ commands.py	2011-06-14 12:09:26 +0000
4
@@ -30,21 +30,14 @@
5
30
    )
30
    )
6
31
31
7
32
32
10
33
def get_layout(layoutname):
33
def get_layoutname(layoutname):
11
34
    """Parse layout name and return a layout.
34
    """Parse layout name and return a normal layout name.
12
35
35
13
36
    :param layout: Name of the layout to retrieve.
36
    :param layout: Name of the layout to retrieve.
14
37
    """
37
    """
15
38
    if isinstance(layoutname, unicode):
38
    if isinstance(layoutname, unicode):
16
39
        layoutname = layoutname.encode("ascii")
39
        layoutname = layoutname.encode("ascii")
25
40
    from bzrlib.plugins.svn.layout import layout_registry
40
    return layoutname
18
41
    from bzrlib.errors import BzrCommandError
19
42
20
43
    try:
21
44
        ret = layout_registry.get(layoutname)()
22
45
    except KeyError:
23
46
        raise BzrCommandError('No such repository layout %r' % layoutname)
24
47
    return ret
26
48
41
27
49
42
28
50
class cmd_svn_import(Command):
43
class cmd_svn_import(Command):
29
@@ -70,7 +63,7 @@
30
70
                     Option('all',
63
                     Option('all',
31
71
                         help='Convert all revisions, even those not in '
64
                         help='Convert all revisions, even those not in '
32
72
                              'current branch history.'),
65
                              'current branch history.'),
34
73
                     Option('layout', type=get_layout,
66
                     Option('layoutname', type=get_layoutname,
35
74
                         help='Repository layout (none, trunk, etc). '
67
                         help='Repository layout (none, trunk, etc). '
36
75
                              'Default: auto.'),
68
                              'Default: auto.'),
37
76
                     Option('keep',
69
                     Option('keep',
38
@@ -87,7 +80,7 @@
39
87
                    ]
80
                    ]
40
88
81
41
89
    def run(self, from_location, to_location=None, format=None, trees=False,
82
    def run(self, from_location, to_location=None, format=None, trees=False,
43
90
            standalone=False, layout=None, all=False, prefix=None, keep=False,
83
            standalone=False, layoutname=None, all=False, prefix=None, keep=False,
44
91
            restore=False, until=None):
84
            restore=False, until=None):
45
92
        from bzrlib import (
85
        from bzrlib import (
46
93
            osutils,
86
            osutils,
47
@@ -152,25 +145,12 @@
48
152
        from_repos.lock_read()
145
        from_repos.lock_read()
49
153
        try:
146
        try:
50
154
            if prefix is not None:
147
            if prefix is not None:
51
155
                if layout is None:
52
156
                    overall_layout = from_repos.get_guessed_layout()
53
157
                else:
54
158
                    overall_layout = layout
55
159
                prefix = prefix.strip("/") + "/"
148
                prefix = prefix.strip("/") + "/"
56
160
                if overall_layout.is_branch(prefix):
57
161
                    raise BzrCommandError("%s appears to contain a branch. "
58
162
                            "For individual branches, use 'bzr branch'." %
59
163
                            from_location)
60
164
                # FIXME: Hint about is_tag()
61
165
                elif overall_layout.is_branch_parent(prefix):
62
166
                    self.outf.write("Importing branches with prefix /%s\n" %
63
167
                        urlutils.unescape_for_display(prefix, self.outf.encoding))
64
168
                else:
65
169
                    raise BzrCommandError("The specified path is inside a branch. "
66
170
                        "Specify a different URL or a different repository layout (see also 'bzr help svn-layout').")
67
171
149
68
172
            if (prefix is not None and
150
            if (prefix is not None and
69
173
                from_repos.transport.check_path(prefix, to_revnum) == NODE_NONE):
151
                from_repos.transport.check_path(prefix, to_revnum) == NODE_NONE):
70
152
                #TODO:Is this really necessary? because once a branch removed in SVN.
71
153
                #Then SVN won't see it anymore, but it's sill in the history!  
72
174
                raise BzrCommandError("Prefix %s does not exist" % prefix)
154
                raise BzrCommandError("Prefix %s does not exist" % prefix)
73
175
155
74
176
            def filter_branch(branch):
156
            def filter_branch(branch):
75
@@ -179,8 +159,10 @@
76
179
                    return False
159
                    return False
77
180
                return True
160
                return True
78
181
161
81
182
            trace.note("Using repository layout: %s",
162
            layout = from_repos.get_layout(layoutname, prefix)
82
183
                       layout or from_repos.get_layout())
163
            if layoutname is 'perfect':
83
164
                prefix = None
84
165
            trace.note("Using repository layout: %s", layout)
85
184
            convert_repository(from_repos, to_location, layout,
166
            convert_repository(from_repos, to_location, layout,
86
185
                not standalone, trees, all, format=format,
167
                not standalone, trees, all, format=format,
87
186
                filter_branch=filter_branch, keep=keep,
168
                filter_branch=filter_branch, keep=keep,
88
187
169
89
=== modified file 'layout/__init__.py'
90
--- layout/__init__.py	2011-06-07 00:39:20 +0000
91
+++ layout/__init__.py	2011-06-14 12:09:26 +0000
92
@@ -306,6 +306,9 @@
93
306
layout_registry.register_lazy("itrunk3", "bzrlib.plugins.svn.layout.standard",
306
layout_registry.register_lazy("itrunk3", "bzrlib.plugins.svn.layout.standard",
94
307
    "InverseTrunkLayout3")
307
    "InverseTrunkLayout3")
95
308
308
96
309
layout_registry.register_lazy("perfect", "bzrlib.plugins.svn.layout.perfect",
97
310
    "PerfectLayout")
98
311
99
309
class RepositoryRegistry(registry.Registry):
312
class RepositoryRegistry(registry.Registry):
100
310
313
101
311
    def get(self, name):
314
    def get(self, name):
102
312
315
103
=== added file 'layout/perfect.py'
104
--- layout/perfect.py	1970-01-01 00:00:00 +0000
105
+++ layout/perfect.py	2011-06-14 12:09:26 +0000
106
@@ -0,0 +1,345 @@
107
1
from subvertpy import NODE_DIR
108
2
109
3
from bzrlib import urlutils
110
4
from bzrlib.plugins.svn import errors as svn_errors
111
5
from bzrlib.plugins.svn.layout import (
112
6
    RepositoryLayout,
113
7
    get_root_paths,
114
8
    wildcard_matches,
115
9
    )
116
10
117
11
class SVNBranches(object):
118
12
    def __init__(self, _subdir):
119
13
120
14
121
15
    def localname_tag(self, path):
122
16
        if self.meta.layout == 'single':
123
17
            return 'tip'
124
18
        default_tag_prefix = self.subdir + 'tags/'
125
19
        if path == self.subdir + 'trunk' or path is None:
126
20
            return 'tip'
127
21
        elif path.startswith(default_tag_prefix):
128
22
            return path[len(default_tag_prefix):]
129
23
        return path
130
24
131
25
    def remotename_tag(self, tag):
132
26
        if self.meta.layout == 'single':
133
27
            return '/'
134
28
        if tag == 'tip' or tag is None:
135
29
            return self.subdir + 'trunk'
136
30
        elif tag.startswith('/'):
137
31
            return tag
138
32
        return self.subdir + 'tags/' + tag
139
33
140
34
    def get_tag_name(self, branch_info = None):
141
35
        if self.meta.layout == 'single':
142
36
            return None
143
37
        if not branch_info:
144
38
            return None
145
39
        if not self.exist_branch(branch_info[2], branch_info[3]):
146
40
            return None
147
41
        return self.is_tag(branch_info[0])
148
42
149
43
    def is_tag(self, branch_path):
150
44
        for tagspath in self.tag_locations:
151
45
            tag_prefix = self.subdir + tagspath + '/'
152
46
            if branch_path.startswith(tag_prefix):
153
47
                return self.localname_tag(branch_path)
154
48
        return None 
155
49
156
50
    def get_paths(self, revision):
157
51
        paths = {}
158
52
        for p,item in revision.paths.iteritems():
159
53
            paths[p] = svn_changes(item)
160
54
        return paths
161
55
162
56
    def update(self, svn, revision):
163
57
        """
164
58
        Given a revision object, determine changes to branches.
165
59
        """
166
60
        self.added_tags, self.deleted_tags = {},{}
167
61
        self.deleted_branches = set()
168
62
        self.modified = {}
169
63
        if self.meta.layout == 'single':
170
64
            self.modified['/'] = 1
171
65
            self.all_branches = {'/':{-1:['/', 0, 1]}}
172
66
            return
173
67
174
68
        paths, revnum = self.get_paths(revision), revision.revnum
175
69
        print(paths, revnum)
176
70
        sorted_paths = sorted(paths.keys())
177
71
        current_test_branches = frozenset(self.all_branches.keys())
178
72
        for p in sorted_paths:
179
73
            if paths[p].action != 'D' and  paths[p].action != 'R':
180
74
                continue
181
75
            np = p + '/'
182
76
            for branch_path in current_test_branches:
183
77
                if not self.exist_branch(branch_path, revnum):
184
78
                    continue
185
79
                if not (branch_path + '/').startswith(np):
186
80
                    continue
187
81
                self.remove_branch(branch_path, revnum)
188
82
189
83
        for p in sorted_paths:
190
84
            copy_from_path = paths[p].copyfrom_path
191
85
            if (copy_from_path is None):
192
86
                continue
193
87
            copy_from_path += '/'
194
88
            parent_rev = paths[p].copyfrom_rev
195
89
            for parent_path in current_test_branches:
196
90
                rn = parent_path + '/'
197
91
                if not rn.startswith(copy_from_path):
198
92
                    continue
199
93
                if not self.exist_branch(parent_path, parent_rev):
200
94
                    continue
201
95
                suffix = ''
202
96
                if (rn != copy_from_path):
203
97
                    suffix = parent_path[len(copy_from_path) - 1:]
204
98
                new_branch_path = p + suffix
205
99
                if self.real_branch(new_branch_path) == new_branch_path:
206
100
                    self.add_branch(new_branch_path, revnum, parent_path, parent_rev)
207
101
208
102
        for p in sorted_paths:
209
103
            new_branch_path = None
210
104
            branch_info = self.get_file_branch(p, revnum)[1]
211
105
            if branch_info is None:
212
106
                new_branch_path = self.create_branch(p)
213
107
            else:
214
108
                self.modified[branch_info[0]] = 1
215
109
            if (paths[p].action == 'D'):
216
110
                continue
217
111
            if self.contains_branch(p, revnum):
218
112
                continue
219
113
220
114
            # If p is an exist file at in some current opened branch 
221
115
222
116
            #Now, /llvm/branches/Apple/williamson processed at the begining!
223
117
            #Carefully handle there is copyfrom, but the from palce didn't have any branches!
224
118
            cp_from = paths[p].copyfrom_path
225
119
            if ( (cp_from and not cp_from.startswith(self.subdir)
226
120
                and self.real_branch(p) == p
227
121
                and (branch_info == None or branch_info[3] == 0)) #This means copies outside the current subdir
228
122
                or self.exist_branch(p, revnum, 2) != None): #This means there is an branch at path p before:)
229
123
                new_branch_path = p
230
124
231
125
            if new_branch_path and svn.checkpath(p.lstrip('/'), revnum) == 'd':
232
126
                sub_path = self.get_file_path(p, new_branch_path)
233
127
                parent_path, parent_rev = self.subdir + 'trunk', 0
234
128
                if cp_from:
235
129
                    parent_path = cp_from[:len(cp_from) - len(sub_path)]
236
130
                    parent_rev = paths[p].copyfrom_rev
237
131
                if sub_path != '':
238
132
                    self.modified[new_branch_path] = 1
239
133
                print("Try add branch with ",p , str(new_branch_path) +':' + str(revnum), sub_path, parent_path + ':' + str(parent_rev))
240
134
                self.add_branch(new_branch_path, revnum, parent_path, parent_rev)
241
135
242
136
    def contains_branch(self, path, revnum):
243
137
        for branch_path, revlist in self.all_branches.iteritems():
244
138
            if not branch_path.startswith(path):
245
139
                continue
246
140
            if -1 in revlist:
247
141
                return True
248
142
        return False
249
143
250
144
    def real_branch(self, path, ret_original = True):
251
145
        new_path = path + '/'
252
146
        #TODO: We can fitler more, user can specify which folder can't 
253
147
        #contains newly created branch:)
254
148
        trunk_suffix = '/trunk/'
255
149
        index = new_path.find("/trunk/")
256
150
        if index == -1:
257
151
            if ret_original:
258
152
                return path
259
153
            return None
260
154
        index = index + len(trunk_suffix)
261
155
        path = new_path[0:index - 1]
262
156
        return path
263
157
264
158
    def create_branch(self, path):
265
159
        if self.meta.layout == 'single':
266
160
            return ''
267
161
268
162
        elts = [p for p in path.split('/') if p]
269
163
        branch_path = self.real_branch(path, False)
270
164
        if branch_path != None:
271
165
            return branch_path
272
166
        elif path.startswith(self.branch_prefix):
273
167
            branch_path = '/'.join(elts[:3])
274
168
        else:
275
169
            branch_path = '/'.join(elts[:-1])
276
170
        branch_path = '/' + branch_path
277
171
        if branch_path.startswith(self.branch_prefix):
278
172
            return branch_path
279
173
        return None
280
174
281
175
    def add_tag(self, hash, tag, revnum):
282
176
        if tag in self.meta.tagmap and not self.meta.tagmap[tag]:
283
177
            return
284
178
        print("Add tag", tag, revnum)
285
179
        parent_id = self.meta.get_tag_parent(hash, revnum)
286
180
        self.added_tags[tag] = parent_id, hash
287
181
288
182
    def add_branch(self, branch_path, open_revision, parent_path, parent_rev, must_add = True):
289
183
        tag_name = self.is_tag(branch_path)
290
184
        branch_info = [parent_path, parent_rev, open_revision, True]
291
185
        from_info = self.exist_branch(branch_path, parent_rev)
292
186
        if tag_name and from_info is None:
293
187
            print("Try to create an tag from nothing!", tag_name, branch_info, from_info)
294
188
            return
295
189
296
190
        self.modified[branch_path] = 0
297
191
        if branch_path in self.all_branches:
298
192
            revlist = self.all_branches[branch_path]
299
193
            if -1 in revlist:
300
194
                revlist[-1][3] = branch_info[3]
301
195
            else:
302
196
                revlist[-1] = branch_info
303
197
        else:
304
198
            self.all_branches[branch_path] = {-1:branch_info}
305
199
306
200
    def remove_branch(self, branch_path, close_revision):
307
201
        self.modified[branch_path] = 0
308
202
        if branch_path in self.all_branches:
309
203
            if (-1 not in self.all_branches[branch_path]):
310
204
                raise Exception('Should contains key -1 in', self.all_branches[branch_path])
311
205
            branch_info = self.all_branches[branch_path].pop(-1)
312
206
            self.all_branches[branch_path][close_revision] = branch_info
313
207
            branch_info = self.exist_branch(branch_path, close_revision, 1)
314
208
            tag_name = self.get_tag_name(branch_info)
315
209
            print('Close branch or tag with info', ['tag name:' + str(tag_name), branch_path, close_revision] + branch_info)
316
210
            if tag_name:
317
211
                self.update_tags[branch_path] = 'D'
318
212
                parent_path = self.get_parent(branch_path, close_revision - 1)[0]
319
213
                self.deleted_tags[tag_name] = self.meta.localname(parent_path), None
320
214
            else:
321
215
                branch = self.meta.localname(branch_path)
322
216
                self.deleted_branches.add(branch)
323
217
        else:
324
218
            raise Exception('Remove an unexist branch',branch_path, 'in', self.all_branches)
325
219
326
220
    def exist_branch(self, branch_path, branch_rev, include_state = 0):
327
221
        '''
328
222
        include_state = 0 means there is an internval [open,close) contains branch_rev
329
223
        include_state = 1 means there is an internval [open,close] contains branch_rev
330
224
        include_state = 2 means if there is an interval [open,close), then just return it.
331
225
            else return the interval that got the maximal close and also the close <= branch_rev
332
226
        '''
333
227
        if branch_path not in self.all_branches.iterkeys():
334
228
            return None
335
229
        revlist = self.all_branches[branch_path]
336
230
        result_revision = None
337
231
        if include_state == 1 and branch_rev in revlist:
338
232
            result_revision = branch_rev
339
233
        elif -1 in revlist and (branch_rev == -1 or revlist[-1][2] <= branch_rev):
340
234
            result_revision = -1
341
235
        else:
342
236
            for close_revision in revlist:
343
237
                open_revision = revlist[close_revision][2]
344
238
                if (open_revision <= branch_rev and branch_rev < close_revision):
345
239
                    result_revision = close_revision
346
240
                    break
347
241
        if result_revision is None and include_state == 2:
348
242
            result_revision = -2
349
243
            for close_revision in revlist:
350
244
                if close_revision <= branch_rev and close_revision > result_revision:
351
245
                    result_revision = close_revision
352
246
            if result_revision == -2:
353
247
                result_revision = None
354
248
        if result_revision is None:
355
249
            return None
356
250
        branch_info = list(revlist[result_revision])
357
251
        branch_info.insert(3, result_revision)
358
252
        return [branch_path, branch_rev] + branch_info
359
253
360
254
    def get_file_path(self, path, branch_path):
361
255
        if path == None or branch_path == None:
362
256
            return ''
363
257
        return path[len(branch_path) + 1:]
364
258
365
259
366
260
class PerfectLayout(RepositoryLayout):
367
261
    def __init__(self, _log = None, _prefix = None):
368
262
        if (_log is None or _prefix is None):
369
263
            return
370
264
        self.log = _log
371
265
        self.added_tags, self.deleted_tags = {},{}
372
266
        self.update_tags = {}
373
267
        self.deleted_branches = set()
374
268
        self.subdir = _prefix
375
269
        self.tag_prefixes = self.subdir + 'tags/'
376
270
        self.branch_prefixes = self.subdir + 'branches/'
377
271
        self.init_trunk = self.subdir + 'trunk/'
378
272
        print('PerfectLayout with log', self.log, self.prefix)
379
273
380
274
    def get_project_prefixes(self, project):
381
275
        return [""]
382
276
383
277
    def supports_tags(self):
384
278
        return True
385
279
386
280
    def get_tag_path(self, name, project=""):
387
281
        """Return the path at which the tag with specified name should be found.
388
282
389
283
        :param name: Name of the tag.
390
284
        :param project: Optional name of the project the tag is for. Can include slashes.
391
285
        :return: Path of the tag.
392
286
        """
393
287
        raise NotImplementedError
394
288
395
289
    def get_tag_name(self, path, project=""):
396
290
        """Determine the tag name from a tag path.
397
291
398
292
        :param path: Path inside the repository.
399
293
        """
400
294
        raise NotImplementedError
401
295
402
296
    def parse(self, path):
403
297
        """Parse a path.
404
298
405
299
        :return: Tuple with type ('tag', 'branch'), project name, branch path and path
406
300
            inside the branch
407
301
        """
408
302
409
303
        raise svn_errors.NotSvnBranchPath(path)
410
304
411
305
    def get_branches(self, repository, revnum, project=None, pb=None):
412
306
        """Retrieve a list of paths that refer to branches in a specific revision.
413
307
414
308
        :return: Iterator over tuples with (project, branch path)
415
309
        """
416
310
        raise NotImplementedError
417
311
418
312
    def get_tags(self, repository, revnum, project=None, pb=None):
419
313
        """Retrieve a list of paths that refer to tags in a specific revision.
420
314
421
315
        :return: Iterator over tuples with (project, branch path)
422
316
        """
423
317
        raise NotImplementedError
424
318
425
319
    def __repr__(self):
426
320
        return "%s" % (self.__class__.__name__)
427
321
428
322
    def __str__(self):
429
323
        return "perfect"
430
324
431
325
    def _is_prefix(self, branches, path, project=None):
432
326
        if (path == self.prefix):
433
327
            return True
434
328
        print('branches', branches, path, project)
435
329
        for branch in branches:
436
330
            if branch.startswith("%s/" % path):
437
331
                return True
438
332
        return False
439
333
    
440
334
    def _get_branches(self):
441
335
        return []
442
336
443
337
    def _get_tags(self):
444
338
        return []
445
339
446
340
    def is_branch_parent(self, path, project=None):
447
341
        return self._is_prefix(self._get_branches(), path, project)
448
342
449
343
    def is_tag_parent(self, path, project=None):
450
344
        print(path)
451
345
        return self._is_prefix(self._get_tags(), path, project)
452
0
346
453
=== modified file 'layout/standard.py'
454
--- layout/standard.py	2011-05-11 12:48:05 +0000
455
+++ layout/standard.py	2011-06-14 12:09:26 +0000
456
@@ -330,7 +330,7 @@
457
330
330
458
331
    def is_branch(self, path, project=None):
331
    def is_branch(self, path, project=None):
459
332
        for bp in self.branches:
332
        for bp in self.branches:
461
333
           if wildcard_matches(path, bp):
333
            if wildcard_matches(path, bp):
462
334
                return True
334
                return True
463
335
        return False
335
        return False
464
336
336
465
337
337
466
=== modified file 'repository.py'
467
--- repository.py	2011-06-09 11:29:06 +0000
468
+++ repository.py	2011-06-14 12:09:26 +0000
469
@@ -659,23 +659,29 @@
470
659
        self.get_config().set_layout(layout)
659
        self.get_config().set_layout(layout)
471
660
        self._layout_source = LAYOUT_SOURCE_CONFIG
660
        self._layout_source = LAYOUT_SOURCE_CONFIG
472
661
661
474
662
    def get_layout(self):
662
    def get_layout(self, layoutname = None, prefix = None):
475
663
        """Determine layout to use for this repository.
663
        """Determine layout to use for this repository.
476
664
664
477
665
        This will use whatever layout the user has specified, or
665
        This will use whatever layout the user has specified, or
478
666
        otherwise the layout that was guessed by bzr-svn.
666
        otherwise the layout that was guessed by bzr-svn.
479
667
        """
667
        """
481
668
        return self.get_layout_source()[0]
668
        return self.get_layout_source(layoutname, prefix)[0]
482
669
669
484
670
    def get_layout_source(self):
670
    def get_layout_source(self, layoutname = None, prefix = None):
485
671
        if self._layout is None:
671
        if self._layout is None:
486
672
            self._layout_source = LAYOUT_SOURCE_MAPPING_MANDATED
672
            self._layout_source = LAYOUT_SOURCE_MAPPING_MANDATED
487
673
            self._layout = self.get_mapping().get_mandated_layout(self)
673
            self._layout = self.get_mapping().get_mandated_layout(self)
488
674
        if self._layout is None:
674
        if self._layout is None:
490
675
            layoutname = self.get_config().get_layout()
675
            layoutname = layoutname or self.get_config().get_layout()
491
676
            if layoutname is not None:
676
            if layoutname is not None:
492
677
                self._layout_source = LAYOUT_SOURCE_CONFIG
677
                self._layout_source = LAYOUT_SOURCE_CONFIG
494
678
                self._layout = layout.layout_registry.get(layoutname)()
678
                try:
495
679
                    if layoutname == 'perfect':
496
680
                        self._layout = layout.layout_registry.get(layoutname)(self._log, prefix)
497
681
                    else: 
498
682
                        self._layout = layout.layout_registry.get(layoutname)()
499
683
                except KeyError:
500
684
                    raise bzr_errors.BzrCommandError('No such repository layout %r' % layoutname)
501
679
        if self._layout is None:
685
        if self._layout is None:
502
680
            branches = self.get_config().get_branches()
686
            branches = self.get_config().get_branches()
503
681
            tags = self.get_config().get_tags()
687
            tags = self.get_config().get_tags()
Status:	Rejected
Rejected by:	Jelmer Vernooij on 2011-06-28
Proposed branch:	lp:~luoyonggang/bzr-svn/perfect-layout
Merge into:	lp:bzr-svn/1.1
Diff against target:	503 lines (+371/-35) 5 files modified commands.py (+11/-29) layout/__init__.py (+3/-0) layout/perfect.py (+345/-0) layout/standard.py (+1/-1) repository.py (+11/-5)
To merge this branch:	bzr merge lp:~luoyonggang/bzr-svn/perfect-layout
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Jelmer Vernooij (community)		2011-06-14	Disapprove on 2011-06-14
Review via email: mp+64530@code.launchpad.net