Merge lp:~abentley/bzr/nested-trees-composite-tree into lp:~bzr/bzr/trunk-old
- nested-trees-composite-tree
- Merge into trunk-old
Proposed by
Aaron Bentley
| Status: | Work in progress |
|---|---|
| Proposed branch: | lp:~abentley/bzr/nested-trees-composite-tree |
| Merge into: | lp:~bzr/bzr/trunk-old |
| Diff against target: |
1484 lines (has conflicts)
Text conflict in bzrlib/tests/__init__.py Text conflict in bzrlib/transform.py |
| To merge this branch: | bzr merge lp:~abentley/bzr/nested-trees-composite-tree |
| Related bugs: |
| Reviewer | Review Type | Date Requested | Status |
|---|---|---|---|
| Martin Pool | Pending | ||
|
Review via email:
|
|||
Commit message
Description of the change
To post a comment you must log in.
Revision history for this message
| Martin Pool (mbp) wrote : | # |
> -----BEGIN PGP SIGNED MESSAGE-----
> Hash: SHA1
>
> Hi Martin,
>
> You wanted some documentation of CompositeTree to be included with the
> patch that introduces it. Since NestedTrees is also introduced by this
> patch and is arguably more important in the long run, I've included
> documentation for it as well.
>
> I hope this is the kind of thing you were looking for.
So yes, it is.
I wonder if this would be better described in the overview of major classes (in HACKING, I think?) than separated out into something only about nested trees. If you were going to add a new documentation file you should link it into the index, but here I think it's better not to add one.
I think for ReST you need a blank line between the heading underline and the following text?
In CompositeTree, I'd like to see something about how you obtain one.
It's good to write it up like this because it makes the issues more clear. For example, what will happen if code gets a CompositeTree and tries to treat it like a regular tree? Will it just error? (Some of these can be discussed in the thread about the general design but probably they should be answered in the docs.) If "by con
1279 +It is constructed from a Tree (typically a RevisionTree or WorkingTree) and a
1280 +Branch.
If you mean you just do
CompositeTree
then a code sample to say so would be unambiguous.
+
+NestedTrees
+-----------
+NestedTrees is an API providing access to a set of nested trees. It is able to
+convert paths and file-ids into references to specific Trees. It provides
+caching, to avoid retrieving the same Tree multiple times. It provides
+locking, to ensure trees are locked and unlocked at appropriate times.
+
+It is used by CompositeTree, and is a recommended API for all other operations.
+It is expected to acquire more capabilities as the needs of sets of nested
+trees become clearer.
Names that sound like they're plurals of some other class name are confusing. (Is this about ``NestedTree``, which sounds like a kind of tree?) Maybe NestedTreeSet or TreeNest?
Again I'd ask how you get one of them.
Thanks
Revision history for this message
| Martin Pool (mbp) wrote : | # |
How did you get on while I was away with the enhancement proposal for the whole thing? Reading that seems like the next step forward.
Revision history for this message
| Aaron Bentley (abentley) wrote : | # |
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
Martin Pool wrote:
> How did you get on while I was away with the enhancement proposal for the whole thing?
I'm working on launchpad stuff for a bit. My unfinished draft is here:
bzr+ssh:
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (GNU/Linux)
Comment: Using GnuPG with Mozilla - http://
iEYEARECAAYFAko
g+oAn2Ux8BctPmo
=KaIe
-----END PGP SIGNATURE-----
Revision history for this message
| Alexander Belchenko (bialix) wrote : | # |
PING. Why this one is blocked?
Unmerged revisions
- 1937. By Aaron Bentley
-
Add documentation of CompositeTree and NestedTrees
- 1936. By Aaron Bentley
-
Merge bzr.dev into composite-tree.
- 1935. By Aaron Bentley
-
Merge bzr.dev into composite-tree.
- 1934. By Aaron Bentley
-
Merge bzr.dev into composite-tree.
- 1933. By Aaron Bentley
-
Merge bzr.dev into composite-tree.
- 1932. By Aaron Bentley
-
Merge bzr.dev into composite-tree.
- 1931. By Aaron Bentley
-
Merge bzr.dev into composite-tree
- 1930. By Aaron Bentley
-
More updates from review
- 1929. By Aaron Bentley
-
More updates from review.
- 1928. By Aaron Bentley
-
Updates from review
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
| 1 | === added file 'bzrlib/composite_tree.py' | |||
| 2 | --- bzrlib/composite_tree.py 1970-01-01 00:00:00 +0000 | |||
| 3 | +++ bzrlib/composite_tree.py 2009-08-31 04:38:31 +0000 | |||
| 4 | @@ -0,0 +1,761 @@ | |||
| 5 | 1 | # Copyright (C) 2007, 2008, 2009 Canonical Ltd | ||
| 6 | 2 | # | ||
| 7 | 3 | # This program is free software; you can redistribute it and/or modify | ||
| 8 | 4 | # it under the terms of the GNU General Public License as published by | ||
| 9 | 5 | # the Free Software Foundation; either version 2 of the License, or | ||
| 10 | 6 | # (at your option) any later version. | ||
| 11 | 7 | # | ||
| 12 | 8 | # This program is distributed in the hope that it will be useful, | ||
| 13 | 9 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 14 | 10 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| 15 | 11 | # GNU General Public License for more details. | ||
| 16 | 12 | # | ||
| 17 | 13 | # You should have received a copy of the GNU General Public License | ||
| 18 | 14 | # along with this program; if not, write to the Free Software | ||
| 19 | 15 | # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
| 20 | 16 | |||
| 21 | 17 | """Tree-like class for manipulating nested trees to be like a single tree""" | ||
| 22 | 18 | |||
| 23 | 19 | from bzrlib import ( | ||
| 24 | 20 | conflicts as _mod_conflicts, | ||
| 25 | 21 | errors, | ||
| 26 | 22 | osutils, | ||
| 27 | 23 | transform, | ||
| 28 | 24 | tree, | ||
| 29 | 25 | ) | ||
| 30 | 26 | |||
| 31 | 27 | class NestedTrees(object): | ||
| 32 | 28 | """Provide data about a collection of nested trees. | ||
| 33 | 29 | |||
| 34 | 30 | This is a sparse interface that has high fidelity to its underlying | ||
| 35 | 31 | implementation. It may be used directly, or as the internal state of | ||
| 36 | 32 | CompositeTree/_CompositeInventory. | ||
| 37 | 33 | """ | ||
| 38 | 34 | |||
| 39 | 35 | def __init__(self, root_tree, root_branch): | ||
| 40 | 36 | self.root_tree = root_tree | ||
| 41 | 37 | self.root_branch = root_branch | ||
| 42 | 38 | self.lock_count = 0 | ||
| 43 | 39 | self.lock_type = None | ||
| 44 | 40 | self._clear_cached_trees() | ||
| 45 | 41 | |||
| 46 | 42 | def _clear_cached_trees(self): | ||
| 47 | 43 | if self.lock_type is not None: | ||
| 48 | 44 | raise AssertionError('Cannot clear cached trees when locked.') | ||
| 49 | 45 | self._subtrees_by_relpath = {} | ||
| 50 | 46 | self._all_trees_scanned = False | ||
| 51 | 47 | self._locked_trees = [] | ||
| 52 | 48 | |||
| 53 | 49 | def lock_read(self): | ||
| 54 | 50 | """Read-lock all open trees, open new trees read-locked.""" | ||
| 55 | 51 | if self.lock_count == 0: | ||
| 56 | 52 | self.root_tree.lock_read() | ||
| 57 | 53 | self.lock_type = 'read' | ||
| 58 | 54 | self._locked_trees.append(self.root_tree) | ||
| 59 | 55 | self.lock_count += 1 | ||
| 60 | 56 | |||
| 61 | 57 | def lock_write(self): | ||
| 62 | 58 | """Write-lock all open trees, open new trees write-locked.""" | ||
| 63 | 59 | if self.lock_count == 0: | ||
| 64 | 60 | self.root_tree.lock_write() | ||
| 65 | 61 | self.lock_type = 'write' | ||
| 66 | 62 | self._locked_trees.append(self.root_tree) | ||
| 67 | 63 | self.lock_count += 1 | ||
| 68 | 64 | |||
| 69 | 65 | def lock_tree_write(self): | ||
| 70 | 66 | """Write-lock all open trees, open new trees write-locked. | ||
| 71 | 67 | |||
| 72 | 68 | Branches are read-locked, instead of being write-locked as usual. | ||
| 73 | 69 | """ | ||
| 74 | 70 | if self.lock_count == 0: | ||
| 75 | 71 | self.root_tree.lock_tree_write() | ||
| 76 | 72 | self.lock_type = 'tree_write' | ||
| 77 | 73 | self._locked_trees.append(self.root_tree) | ||
| 78 | 74 | self.lock_count += 1 | ||
| 79 | 75 | |||
| 80 | 76 | def unlock(self): | ||
| 81 | 77 | """Unlock open trees.""" | ||
| 82 | 78 | self.lock_count -= 1 | ||
| 83 | 79 | if self.lock_count < 0: | ||
| 84 | 80 | raise AssertionError('lock count is negative.') | ||
| 85 | 81 | if self.lock_count == 0: | ||
| 86 | 82 | for tree in reversed(self._locked_trees): | ||
| 87 | 83 | tree.unlock() | ||
| 88 | 84 | self.lock_type = None | ||
| 89 | 85 | self._clear_cached_trees() | ||
| 90 | 86 | |||
| 91 | 87 | def _must_be_locked(self): | ||
| 92 | 88 | if self.lock_type is None: | ||
| 93 | 89 | raise errors.ObjectNotLocked(self) | ||
| 94 | 90 | |||
| 95 | 91 | def paths_info(self, paths): | ||
| 96 | 92 | """Return path, relpath, inventory entry, and tree for input paths. | ||
| 97 | 93 | |||
| 98 | 94 | The path is the path to the subtree relative to the root tree. The | ||
| 99 | 95 | relpath is the path within the subtree. The inventory entry will be | ||
| 100 | 96 | None if the path is not versioned. The tree is the subtree | ||
| 101 | 97 | containing the relpath. | ||
| 102 | 98 | |||
| 103 | 99 | :param paths: A list of paths relative to the root tree. | ||
| 104 | 100 | :return: a list of (path, relpath, entry, tree) tuples. | ||
| 105 | 101 | """ | ||
| 106 | 102 | self._must_be_locked() | ||
| 107 | 103 | return [self._path_info(p) for p in paths] | ||
| 108 | 104 | |||
| 109 | 105 | def _path_info(self, path): | ||
| 110 | 106 | """Find the relpath, tree and inventory entry for a path. | ||
| 111 | 107 | |||
| 112 | 108 | The path is the path to the subtree relative to the root tree. The | ||
| 113 | 109 | relpath is the path within the subtree. The inventory will be | ||
| 114 | 110 | None if the path is not versioned. The tree is the subtree | ||
| 115 | 111 | containing the relpath. | ||
| 116 | 112 | |||
| 117 | 113 | :param path: A path relative to the root tree. | ||
| 118 | 114 | :return: a (path, relpath, entry, tree) tuple. | ||
| 119 | 115 | """ | ||
| 120 | 116 | parts = osutils.splitpath(path) | ||
| 121 | 117 | tree = self.root_tree | ||
| 122 | 118 | branch = self.root_branch | ||
| 123 | 119 | node = tree.inventory.root | ||
| 124 | 120 | relpath = [] | ||
| 125 | 121 | for part in parts: | ||
| 126 | 122 | relpath.append(part) | ||
| 127 | 123 | children = getattr(node, 'children', {}) | ||
| 128 | 124 | node = children.get(part) | ||
| 129 | 125 | if node is None: | ||
| 130 | 126 | return path, osutils.pathjoin(*relpath), None, tree | ||
| 131 | 127 | try: | ||
| 132 | 128 | kind = tree.kind(node.file_id) | ||
| 133 | 129 | except errors.NoSuchFile: | ||
| 134 | 130 | pass | ||
| 135 | 131 | else: | ||
| 136 | 132 | if kind == 'tree-reference': | ||
| 137 | 133 | tree, branch = self.get_tree_branch(branch, tree, | ||
| 138 | 134 | node.file_id, osutils.pathjoin(*relpath)) | ||
| 139 | 135 | node = tree.inventory.root | ||
| 140 | 136 | relpath = [] | ||
| 141 | 137 | continue | ||
| 142 | 138 | if relpath == []: | ||
| 143 | 139 | relpath_str = '' | ||
| 144 | 140 | else: | ||
| 145 | 141 | relpath_str = osutils.pathjoin(*relpath) | ||
| 146 | 142 | return path, relpath_str, node, tree | ||
| 147 | 143 | |||
| 148 | 144 | def get_tree(self, file_id): | ||
| 149 | 145 | """Return the Tree that contains a given file-id.""" | ||
| 150 | 146 | return self.get_tree_and_treepath(file_id)[0] | ||
| 151 | 147 | |||
| 152 | 148 | def get_tree_and_treepath(self, file_id, skip_references=False): | ||
| 153 | 149 | """Get a tree containing file_id and path relative to the root tree. | ||
| 154 | 150 | |||
| 155 | 151 | The path is the path to the subtree, not the file in the subtree. | ||
| 156 | 152 | |||
| 157 | 153 | :skip_references: if True, only results where the file_id is not | ||
| 158 | 154 | a tree reference will be supplied. | ||
| 159 | 155 | """ | ||
| 160 | 156 | for path, tree in self.all_trees().iteritems(): | ||
| 161 | 157 | if file_id in tree.inventory: | ||
| 162 | 158 | if skip_references: | ||
| 163 | 159 | try: | ||
| 164 | 160 | if tree.kind(file_id) == 'tree-reference': | ||
| 165 | 161 | continue | ||
| 166 | 162 | except errors.NoSuchFile: | ||
| 167 | 163 | pass | ||
| 168 | 164 | return tree, path | ||
| 169 | 165 | else: | ||
| 170 | 166 | raise errors.NoSuchId(self, file_id) | ||
| 171 | 167 | |||
| 172 | 168 | def get_path_info(self, path): | ||
| 173 | 169 | """Determine the tree containing a path and the tree's pathname. | ||
| 174 | 170 | |||
| 175 | 171 | :return: a tuple of (tree, tree_path, relpath), where tree_path | ||
| 176 | 172 | is the path to the tree, relative to the root_tree, and relpath | ||
| 177 | 173 | is the path relative to the returned tree. | ||
| 178 | 174 | """ | ||
| 179 | 175 | trees = self.all_trees() | ||
| 180 | 176 | prefix = path | ||
| 181 | 177 | while True: | ||
| 182 | 178 | prefix = osutils.dirname(prefix) | ||
| 183 | 179 | subpath = path[len(prefix):] | ||
| 184 | 180 | subpath = subpath.lstrip('/') | ||
| 185 | 181 | try: | ||
| 186 | 182 | return trees[prefix], prefix, subpath | ||
| 187 | 183 | except KeyError: | ||
| 188 | 184 | pass | ||
| 189 | 185 | if subpath == '': | ||
| 190 | 186 | raise AssertionError('Subpath cannot be empty.') | ||
| 191 | 187 | |||
| 192 | 188 | def iter_pathinfo_by_tree(self, paths): | ||
| 193 | 189 | """Iterate through the path information for provided paths. | ||
| 194 | 190 | |||
| 195 | 191 | Iterates through (tree, tree_path, relpaths) tuples, where | ||
| 196 | 192 | tree is a tree containing some of the paths, tree_path is the relative | ||
| 197 | 193 | path to the tree from the root_tree, and relpaths are the paths within | ||
| 198 | 194 | the returned tree. | ||
| 199 | 195 | """ | ||
| 200 | 196 | tree_path = None | ||
| 201 | 197 | tree = None | ||
| 202 | 198 | # Reverse sort should guarantee that all subtree paths are processed | ||
| 203 | 199 | # before tree paths. So if path.startswith(tree_path), we're in | ||
| 204 | 200 | # the same tree. | ||
| 205 | 201 | for path in sorted(paths, reverse=True): | ||
| 206 | 202 | if tree_path is None or not path.startswith(tree_path): | ||
| 207 | 203 | if tree is not None: | ||
| 208 | 204 | yield tree, tree_path, subpaths | ||
| 209 | 205 | tree, tree_path, subpath = self.get_path_info(path) | ||
| 210 | 206 | subpaths = [subpath] | ||
| 211 | 207 | else: | ||
| 212 | 208 | subpaths.append(path[len(tree_path):].lstrip('/')) | ||
| 213 | 209 | if tree is not None: | ||
| 214 | 210 | yield tree, tree_path, subpaths | ||
| 215 | 211 | |||
| 216 | 212 | def _scan_subtrees(self): | ||
| 217 | 213 | self._must_be_locked() | ||
| 218 | 214 | def do_scan(prefix, relpath, tree, containing_tree, branch): | ||
| 219 | 215 | self._register_tree_relpath(tree, containing_tree, relpath) | ||
| 220 | 216 | for path, file_id in tree.iter_references(): | ||
| 221 | 217 | tree_path = tree.id2path(file_id) | ||
| 222 | 218 | composite_path = osutils.pathjoin(prefix, tree_path) | ||
| 223 | 219 | subtree, subbranch = self.get_tree_branch(branch, tree, | ||
| 224 | 220 | file_id, tree_path) | ||
| 225 | 221 | do_scan(composite_path, tree_path, subtree, tree, subbranch) | ||
| 226 | 222 | do_scan('', '', self.root_tree, None, self.root_branch) | ||
| 227 | 223 | |||
| 228 | 224 | def _register_tree_relpath(self, tree, containing_tree, relpath): | ||
| 229 | 225 | """Register the relpath of a Tree in the relevant dicts.""" | ||
| 230 | 226 | tree_relpaths = self._subtrees_by_relpath.get(containing_tree, {}) | ||
| 231 | 227 | tree_relpaths[relpath] = tree | ||
| 232 | 228 | self._subtrees_by_relpath[containing_tree] = tree_relpaths | ||
| 233 | 229 | |||
| 234 | 230 | def get_tree_branch(self, branch, tree, file_id, path): | ||
| 235 | 231 | """Retrieve the tree and branch for a subtree path | ||
| 236 | 232 | |||
| 237 | 233 | :param branch: The branch associated with the containing tree | ||
| 238 | 234 | :param tree: The containing tree | ||
| 239 | 235 | :param file_id: The file id of the subtree | ||
| 240 | 236 | :param path: The tree-relative path to the subtree | ||
| 241 | 237 | """ | ||
| 242 | 238 | subbranch = branch.reference_parent(file_id, path) | ||
| 243 | 239 | try: | ||
| 244 | 240 | subtree = self._subtrees_by_relpath[tree][path] | ||
| 245 | 241 | except KeyError: | ||
| 246 | 242 | # Unknown tree, so we must try and retrieve it. | ||
| 247 | 243 | subtree = tree.get_nested_tree(file_id, branch) | ||
| 248 | 244 | # Tree must be locked to match the other components of this | ||
| 249 | 245 | # NestedTree so that they all behave the same. | ||
| 250 | 246 | if self.lock_type is not None: | ||
| 251 | 247 | if self.lock_type == 'read': | ||
| 252 | 248 | subtree.lock_read() | ||
| 253 | 249 | elif self.lock_type == 'write': | ||
| 254 | 250 | subtree.lock_write() | ||
| 255 | 251 | elif self.lock_type == 'tree_write': | ||
| 256 | 252 | subtree.lock_tree_write() | ||
| 257 | 253 | self._locked_trees.append(subtree) | ||
| 258 | 254 | self._register_tree_relpath(subtree, tree, path) | ||
| 259 | 255 | return subtree, subbranch | ||
| 260 | 256 | |||
| 261 | 257 | def all_trees(self): | ||
| 262 | 258 | """Return a dict of composite_path to tree for all subtrees.""" | ||
| 263 | 259 | if not self._all_trees_scanned: | ||
| 264 | 260 | self._scan_subtrees() | ||
| 265 | 261 | self._all_trees_scanned = True | ||
| 266 | 262 | root_tree_paths = {} | ||
| 267 | 263 | def do_tree(tree, root_tree_path): | ||
| 268 | 264 | root_tree_paths[root_tree_path] = tree | ||
| 269 | 265 | subtrees = self._subtrees_by_relpath.get(tree, {}) | ||
| 270 | 266 | for relpath, subtree in subtrees.iteritems(): | ||
| 271 | 267 | do_tree(subtree, osutils.pathjoin(root_tree_path, relpath)) | ||
| 272 | 268 | do_tree(self.root_tree, '') | ||
| 273 | 269 | return root_tree_paths | ||
| 274 | 270 | |||
| 275 | 271 | |||
| 276 | 272 | class _CompositeInventory(object): | ||
| 277 | 273 | """An inventory that combines the inventories of several subtrees. | ||
| 278 | 274 | |||
| 279 | 275 | Intended for use as CompositeTree.inventory, not for direct instantiation. | ||
| 280 | 276 | """ | ||
| 281 | 277 | |||
| 282 | 278 | def __init__(self, nested_trees): | ||
| 283 | 279 | self._nested_trees = nested_trees | ||
| 284 | 280 | |||
| 285 | 281 | def _get_ci_path_info(self, path): | ||
| 286 | 282 | file_id = None | ||
| 287 | 283 | tree = self._nested_trees.root_tree | ||
| 288 | 284 | node = tree.inventory.root | ||
| 289 | 285 | canonical_path = [] | ||
| 290 | 286 | remaining_path = osutils.splitpath(path) | ||
| 291 | 287 | while len(remaining_path) > 0: | ||
| 292 | 288 | part = remaining_path[0] | ||
| 293 | 289 | next_node = None | ||
| 294 | 290 | children = getattr(node, 'children', {}) | ||
| 295 | 291 | for child in children.itervalues(): | ||
| 296 | 292 | if child.name.lower() == part.lower(): | ||
| 297 | 293 | next_node = child | ||
| 298 | 294 | if child.name == part: | ||
| 299 | 295 | break | ||
| 300 | 296 | if next_node is None: | ||
| 301 | 297 | break | ||
| 302 | 298 | remaining_path.pop(0) | ||
| 303 | 299 | canonical_path.append(next_node.name) | ||
| 304 | 300 | node = next_node | ||
| 305 | 301 | if node.kind == 'tree-reference': | ||
| 306 | 302 | tree, path_ = self._nested_trees.get_tree_and_treepath( | ||
| 307 | 303 | node.file_id, skip_references=True) | ||
| 308 | 304 | node = tree.inventory.root | ||
| 309 | 305 | if node is not None: | ||
| 310 | 306 | file_id = node.file_id | ||
| 311 | 307 | canonical_path.extend(remaining_path) | ||
| 312 | 308 | if len(canonical_path) == 0: | ||
| 313 | 309 | result = '' | ||
| 314 | 310 | else: | ||
| 315 | 311 | result = osutils.pathjoin(*canonical_path) | ||
| 316 | 312 | return result, file_id | ||
| 317 | 313 | |||
| 318 | 314 | def path2id(self, path): | ||
| 319 | 315 | """See Inventory.path2id.""" | ||
| 320 | 316 | path, relpath, entry, tree = self._nested_trees.paths_info([path])[0] | ||
| 321 | 317 | if entry is None: | ||
| 322 | 318 | return None | ||
| 323 | 319 | return entry.file_id | ||
| 324 | 320 | |||
| 325 | 321 | def id2path(self, file_id): | ||
| 326 | 322 | """See Inventory.id2path.""" | ||
| 327 | 323 | tree, path = self._nested_trees.get_tree_and_treepath(file_id) | ||
| 328 | 324 | return osutils.pathjoin(*[path, tree.id2path(file_id)]) | ||
| 329 | 325 | |||
| 330 | 326 | def get_file_kind(self, file_id): | ||
| 331 | 327 | """See Inventory.get_file_kind.""" | ||
| 332 | 328 | tree = self._nested_trees.get_tree_and_treepath(file_id, | ||
| 333 | 329 | skip_references=True)[0] | ||
| 334 | 330 | return tree.inventory.get_file_kind(file_id) | ||
| 335 | 331 | |||
| 336 | 332 | def iter_entries_by_dir(self, specific_file_ids=None, _tree=None, | ||
| 337 | 333 | _branch=None, _root=''): | ||
| 338 | 334 | """See Inventory.iter_entries_by_dir.""" | ||
| 339 | 335 | tree = _tree | ||
| 340 | 336 | root = _root | ||
| 341 | 337 | branch = _branch | ||
| 342 | 338 | if tree is None: | ||
| 343 | 339 | tree = self._nested_trees.root_tree | ||
| 344 | 340 | if branch is None: | ||
| 345 | 341 | branch = self._nested_trees.root_branch | ||
| 346 | 342 | for subpath, entry in tree.iter_entries_by_dir(): | ||
| 347 | 343 | if subpath == '': | ||
| 348 | 344 | path = root | ||
| 349 | 345 | else: | ||
| 350 | 346 | path = osutils.pathjoin(root, subpath) | ||
| 351 | 347 | try: | ||
| 352 | 348 | kind = tree.kind(entry.file_id) | ||
| 353 | 349 | except errors.NoSuchFile: | ||
| 354 | 350 | kind = None | ||
| 355 | 351 | if kind == 'tree-reference': | ||
| 356 | 352 | subtree, subbranch = self._nested_trees.get_tree_branch( | ||
| 357 | 353 | branch, tree, entry.file_id, path) | ||
| 358 | 354 | for path, entry in self.iter_entries_by_dir( | ||
| 359 | 355 | specific_file_ids, _tree=subtree, | ||
| 360 | 356 | _branch=subbranch, _root=path): | ||
| 361 | 357 | yield path, entry | ||
| 362 | 358 | else: | ||
| 363 | 359 | if (specific_file_ids is None or entry.file_id in | ||
| 364 | 360 | specific_file_ids): | ||
| 365 | 361 | yield path, entry | ||
| 366 | 362 | |||
| 367 | 363 | def iter_entries(self, from_dir=None): | ||
| 368 | 364 | """See Tree.iter_entries. | ||
| 369 | 365 | |||
| 370 | 366 | Note: violates the expected output order, but this is not generally | ||
| 371 | 367 | a problem. | ||
| 372 | 368 | """ | ||
| 373 | 369 | if from_dir is not None: | ||
| 374 | 370 | from_dir_path = self.id2path(from_dir) | ||
| 375 | 371 | for path, entry in self.iter_entries_by_dir(): | ||
| 376 | 372 | if from_dir is not None: | ||
| 377 | 373 | if not path.startswith(from_dir_path): | ||
| 378 | 374 | continue | ||
| 379 | 375 | path = path[len(from_dir_path):].lstrip('/') | ||
| 380 | 376 | yield path, entry | ||
| 381 | 377 | |||
| 382 | 378 | def __getitem__(self, file_id): | ||
| 383 | 379 | tree = self._nested_trees.get_tree(file_id) | ||
| 384 | 380 | return tree.inventory[file_id] | ||
| 385 | 381 | |||
| 386 | 382 | def __contains__(self, file_id): | ||
| 387 | 383 | try: | ||
| 388 | 384 | self._nested_trees.get_tree(file_id) | ||
| 389 | 385 | except errors.NoSuchId: | ||
| 390 | 386 | return False | ||
| 391 | 387 | else: | ||
| 392 | 388 | return True | ||
| 393 | 389 | |||
| 394 | 390 | |||
| 395 | 391 | class CompositeTree(object): | ||
| 396 | 392 | """Implements parts of Tree interface in terms of subtrees. | ||
| 397 | 393 | |||
| 398 | 394 | Essentially, this is a by-value representation of a set of nested | ||
| 399 | 395 | subtrees. | ||
| 400 | 396 | Care should be taken in its use-- not suitable for every problem. | ||
| 401 | 397 | """ | ||
| 402 | 398 | |||
| 403 | 399 | def __init__(self, root_tree, root_branch): | ||
| 404 | 400 | self._nested_trees = NestedTrees(root_tree, root_branch) | ||
| 405 | 401 | self.inventory = _CompositeInventory(self._nested_trees) | ||
| 406 | 402 | |||
| 407 | 403 | @property | ||
| 408 | 404 | def basedir(self): | ||
| 409 | 405 | """See WorkingTree.basedir.""" | ||
| 410 | 406 | return self._nested_trees.root_tree.basedir | ||
| 411 | 407 | |||
| 412 | 408 | def move(self, from_paths, to_dir, after=False, _to_names=None): | ||
| 413 | 409 | """Rename files, possibly across trees""" | ||
| 414 | 410 | self.lock_tree_write() | ||
| 415 | 411 | try: | ||
| 416 | 412 | paths_info = self._nested_trees.paths_info(from_paths+[to_dir]) | ||
| 417 | 413 | to_path, to_relpath, new_parent, to_tree = paths_info[-1] | ||
| 418 | 414 | if _to_names is not None and paths_info[0][2] is None: | ||
| 419 | 415 | raise errors.BzrRenameFailedError(from_paths[0], | ||
| 420 | 416 | osutils.pathjoin(to_dir, _to_names[0]), | ||
| 421 | 417 | errors.NotVersionedError(path=from_paths[0])) | ||
| 422 | 418 | if new_parent is None: | ||
| 423 | 419 | if _to_names is None: | ||
| 424 | 420 | from_ = '' | ||
| 425 | 421 | to = to_dir | ||
| 426 | 422 | else: | ||
| 427 | 423 | from_ = from_paths[0] | ||
| 428 | 424 | to = osutils.pathjoin(to_dir, _to_names[0]) | ||
| 429 | 425 | raise errors.BzrMoveFailedError(from_, to, | ||
| 430 | 426 | errors.NotVersionedError(path=to_dir)) | ||
| 431 | 427 | pending_trees = {} | ||
| 432 | 428 | result = [] | ||
| 433 | 429 | for path, relpath, entry, tree, in paths_info: | ||
| 434 | 430 | if entry is None: | ||
| 435 | 431 | raise errors.BzrMoveFailedError(path, '', | ||
| 436 | 432 | errors.NotVersionedError(path=str(path))) | ||
| 437 | 433 | if tree.basedir not in pending_trees: | ||
| 438 | 434 | pending_trees[tree.basedir] = tree | ||
| 439 | 435 | pairs = [] | ||
| 440 | 436 | changes = [] | ||
| 441 | 437 | |||
| 442 | 438 | for num, (from_path, from_relpath, entry, from_tree) in\ | ||
| 443 | 439 | enumerate(paths_info[:-1]): | ||
| 444 | 440 | full_to_path = osutils.pathjoin(to_path, entry.name) | ||
| 445 | 441 | pairs.append((from_path, full_to_path)) | ||
| 446 | 442 | new_entry = entry.copy() | ||
| 447 | 443 | new_entry.parent_id = new_parent.file_id | ||
| 448 | 444 | if _to_names is not None: | ||
| 449 | 445 | new_entry.name = _to_names[num] | ||
| 450 | 446 | changes.append((from_path, full_to_path, new_entry.file_id, | ||
| 451 | 447 | new_entry)) | ||
| 452 | 448 | if not after: | ||
| 453 | 449 | self._move_files(to_path, to_tree, _to_names, paths_info[:-1]) | ||
| 454 | 450 | self.apply_inventory_delta(changes) | ||
| 455 | 451 | return pairs | ||
| 456 | 452 | finally: | ||
| 457 | 453 | self.unlock() | ||
| 458 | 454 | |||
| 459 | 455 | def _move_files(self, to_path, to_tree, to_names, paths_info): | ||
| 460 | 456 | trans_id_tree_path = {} | ||
| 461 | 457 | tt = transform.TreeTransform(self._nested_trees.root_tree) | ||
| 462 | 458 | parent_trans_id = tt.trans_id_tree_path(to_path) | ||
| 463 | 459 | for num, (from_path, from_relpath, entry, from_tree) in enumerate( | ||
| 464 | 460 | paths_info): | ||
| 465 | 461 | # If the source doesn't exist and the target does, | ||
| 466 | 462 | # don't touch the files but just update the inventory. | ||
| 467 | 463 | to_exists = to_tree.has_filename(osutils.pathjoin(to_path, | ||
| 468 | 464 | entry.name)) | ||
| 469 | 465 | from_exists = from_tree.has_filename(from_relpath) | ||
| 470 | 466 | if not from_exists and to_exists: | ||
| 471 | 467 | continue | ||
| 472 | 468 | |||
| 473 | 469 | file_trans_id = tt.trans_id_tree_path(from_path) | ||
| 474 | 470 | trans_id_tree_path[file_trans_id] = from_path | ||
| 475 | 471 | if to_names is not None: | ||
| 476 | 472 | to_name = to_names[num] | ||
| 477 | 473 | else: | ||
| 478 | 474 | to_name = entry.name | ||
| 479 | 475 | tt.adjust_path(to_name, parent_trans_id, file_trans_id) | ||
| 480 | 476 | try: | ||
| 481 | 477 | try: | ||
| 482 | 478 | tt.apply(skip_inventory=True) | ||
| 483 | 479 | except errors.MalformedTransform, e: | ||
| 484 | 480 | if e.conflicts[0][0] == 'duplicate': | ||
| 485 | 481 | fp = transform.FinalPaths(tt) | ||
| 486 | 482 | source = trans_id_tree_path[e.conflicts[0][1]] | ||
| 487 | 483 | dest = fp.get_path(e.conflicts[0][1]) | ||
| 488 | 484 | raise errors.RenameFailedFilesExist(source, dest) | ||
| 489 | 485 | else: | ||
| 490 | 486 | raise | ||
| 491 | 487 | finally: | ||
| 492 | 488 | tt.finalize() | ||
| 493 | 489 | |||
| 494 | 490 | def rename_one(self, from_rel, to_rel, after=False): | ||
| 495 | 491 | """See WorkingTree.rename_one.""" | ||
| 496 | 492 | # We could be moving a file over subtree boundaries, figure out which | ||
| 497 | 493 | # trees are used. | ||
| 498 | 494 | self.lock_tree_write() | ||
| 499 | 495 | try: | ||
| 500 | 496 | from_tree, from_prefix, from_relpath = ( | ||
| 501 | 497 | self._nested_trees.get_path_info(from_rel)) | ||
| 502 | 498 | to_tree, to_prefix, to_relpath = ( | ||
| 503 | 499 | self._nested_trees.get_path_info(to_rel)) | ||
| 504 | 500 | if from_tree == to_tree: | ||
| 505 | 501 | self._nested_trees.root_tree.rename_one(from_rel, to_rel, | ||
| 506 | 502 | after=after) | ||
| 507 | 503 | else: | ||
| 508 | 504 | file_id = self.path2id(from_rel) | ||
| 509 | 505 | osutils.rename(osutils.pathjoin(from_prefix, from_relpath) | ||
| 510 | 506 | , osutils.pathjoin(to_prefix, to_relpath)) | ||
| 511 | 507 | to_tree.add([to_relpath], ids=[file_id]) | ||
| 512 | 508 | from_tree.remove([from_relpath]) | ||
| 513 | 509 | finally: | ||
| 514 | 510 | self.unlock() | ||
| 515 | 511 | |||
| 516 | 512 | def get_file(self, file_id): | ||
| 517 | 513 | """See Tree.get_file.""" | ||
| 518 | 514 | return self._nested_trees.get_tree(file_id).get_file(file_id) | ||
| 519 | 515 | |||
| 520 | 516 | def get_file_text(self, file_id, path=None): | ||
| 521 | 517 | """See Tree.get_file_text.""" | ||
| 522 | 518 | tree, relpath = self._find_tree_path(file_id, path) | ||
| 523 | 519 | return tree.get_file_text(file_id, relpath) | ||
| 524 | 520 | |||
| 525 | 521 | def get_file_size(self, file_id): | ||
| 526 | 522 | """See Tree.get_file_size.""" | ||
| 527 | 523 | return self._nested_trees.get_tree(file_id).get_file_size(file_id) | ||
| 528 | 524 | |||
| 529 | 525 | def _find_tree_path(self, file_id, path): | ||
| 530 | 526 | if path is not None: | ||
| 531 | 527 | path, relpath, entry, tree =\ | ||
| 532 | 528 | self._nested_trees.paths_info([path])[0] | ||
| 533 | 529 | else: | ||
| 534 | 530 | tree = self._nested_trees.get_tree(file_id) | ||
| 535 | 531 | relpath = None | ||
| 536 | 532 | return tree, relpath | ||
| 537 | 533 | |||
| 538 | 534 | def is_executable(self, file_id, path=None): | ||
| 539 | 535 | """See RevisionTree.is_executable.""" | ||
| 540 | 536 | tree, path = self._find_tree_path(file_id, path) | ||
| 541 | 537 | return tree.is_executable(file_id, path) | ||
| 542 | 538 | |||
| 543 | 539 | def has_id(self, file_id): | ||
| 544 | 540 | """See Tree.has_id.""" | ||
| 545 | 541 | try: | ||
| 546 | 542 | tree = self._nested_trees.get_tree(file_id) | ||
| 547 | 543 | except errors.NoSuchId: | ||
| 548 | 544 | return False | ||
| 549 | 545 | if tree is None: | ||
| 550 | 546 | return False | ||
| 551 | 547 | return tree.has_id(file_id) | ||
| 552 | 548 | |||
| 553 | 549 | def changes_from(self, other, want_unchanged=False, specific_files=None, | ||
| 554 | 550 | extra_trees=None, require_versioned=False, include_root=False, | ||
| 555 | 551 | want_unversioned=False): | ||
| 556 | 552 | """Return a TreeDelta of the changes from other to this tree. | ||
| 557 | 553 | |||
| 558 | 554 | :param other: A tree to compare with. | ||
| 559 | 555 | :param specific_files: An optional list of file paths to restrict the | ||
| 560 | 556 | comparison to. When mapping filenames to ids, all matches in all | ||
| 561 | 557 | trees (including optional extra_trees) are used, and all children | ||
| 562 | 558 | of matched directories are included. | ||
| 563 | 559 | :param want_unchanged: An optional boolean requesting the inclusion | ||
| 564 | 560 | of unchanged entries in the result. | ||
| 565 | 561 | :param extra_trees: An optional list of additional trees to use when | ||
| 566 | 562 | mapping the contents of specific_files (paths) to file_ids. | ||
| 567 | 563 | :param require_versioned: An optional boolean (defaults to False). | ||
| 568 | 564 | When supplied and True all the 'specific_files' must be | ||
| 569 | 565 | versioned, or a PathsNotVersionedError will be thrown. | ||
| 570 | 566 | :param want_unversioned: Scan for unversioned paths. | ||
| 571 | 567 | |||
| 572 | 568 | The comparison will be performed by an InterTree object looked up on | ||
| 573 | 569 | self and other. | ||
| 574 | 570 | """ | ||
| 575 | 571 | # Martin observes that Tree.changes_from returns a TreeDelta and this | ||
| 576 | 572 | # may confuse people, because the class name of the returned object | ||
| 577 | 573 | # is a synonym of the object referenced in the method name. | ||
| 578 | 574 | return tree.InterTree.get(other, self).compare( | ||
| 579 | 575 | want_unchanged=want_unchanged, | ||
| 580 | 576 | specific_files=specific_files, | ||
| 581 | 577 | extra_trees=extra_trees, | ||
| 582 | 578 | require_versioned=require_versioned, | ||
| 583 | 579 | include_root=include_root, | ||
| 584 | 580 | want_unversioned=want_unversioned, | ||
| 585 | 581 | ) | ||
| 586 | 582 | |||
| 587 | 583 | def paths2ids(self, paths, trees=[], require_versioned=True): | ||
| 588 | 584 | """See Tree.paths2ids.""" | ||
| 589 | 585 | return tree.find_ids_across_trees(paths, [self] + list(trees), | ||
| 590 | 586 | require_versioned) | ||
| 591 | 587 | |||
| 592 | 588 | def path2id(self, path): | ||
| 593 | 589 | """See Tree.path2id.""" | ||
| 594 | 590 | # FIXME -- shouldn't return missing files | ||
| 595 | 591 | return self.inventory.path2id(path) | ||
| 596 | 592 | |||
| 597 | 593 | def iter_changes(self, from_tree, include_unchanged=False, | ||
| 598 | 594 | specific_files=None, pb=None, extra_trees=None, | ||
| 599 | 595 | require_versioned=True, want_unversioned=False): | ||
| 600 | 596 | """See InterTree.iter_changes.""" | ||
| 601 | 597 | intertree = tree.InterTree.get(from_tree, self) | ||
| 602 | 598 | return intertree.iter_changes(include_unchanged, specific_files, pb, | ||
| 603 | 599 | extra_trees, require_versioned, | ||
| 604 | 600 | want_unversioned=want_unversioned) | ||
| 605 | 601 | |||
| 606 | 602 | def lock_read(self): | ||
| 607 | 603 | """See Tree.lock_read.""" | ||
| 608 | 604 | self._nested_trees.lock_read() | ||
| 609 | 605 | |||
| 610 | 606 | def lock_write(self): | ||
| 611 | 607 | """See MutableTree.lock_write.""" | ||
| 612 | 608 | self._nested_trees.lock_write() | ||
| 613 | 609 | |||
| 614 | 610 | def lock_tree_write(self): | ||
| 615 | 611 | """See MutableTree.lock_tree_write.""" | ||
| 616 | 612 | self._nested_trees.lock_tree_write() | ||
| 617 | 613 | |||
| 618 | 614 | def unlock(self): | ||
| 619 | 615 | """See Tree.unlock.""" | ||
| 620 | 616 | self._nested_trees.unlock() | ||
| 621 | 617 | |||
| 622 | 618 | def extras(self): | ||
| 623 | 619 | """See Tree.extras.""" | ||
| 624 | 620 | result = [] | ||
| 625 | 621 | for prefix, tree in self._nested_trees.all_trees().iteritems(): | ||
| 626 | 622 | result.extend(osutils.pathjoin(prefix, p) | ||
| 627 | 623 | for p in tree.extras()) | ||
| 628 | 624 | return iter(result) | ||
| 629 | 625 | |||
| 630 | 626 | def iter_entries_by_dir(self, specific_file_ids=None, _tree=None, | ||
| 631 | 627 | _branch=None, _root=''): | ||
| 632 | 628 | """See Tree.iter_entries_by_dir.""" | ||
| 633 | 629 | return self.inventory.iter_entries_by_dir(specific_file_ids) | ||
| 634 | 630 | |||
| 635 | 631 | def conflicts(self): | ||
| 636 | 632 | """See WorkingTree.conflicts.""" | ||
| 637 | 633 | # FIXME adjust paths in conflicts | ||
| 638 | 634 | conflicts = [] | ||
| 639 | 635 | for prefix, tree in self._nested_trees.all_trees().iteritems(): | ||
| 640 | 636 | conflicts.extend(tree.conflicts()) | ||
| 641 | 637 | return _mod_conflicts.ConflictList(conflicts) | ||
| 642 | 638 | |||
| 643 | 639 | def all_file_ids(self): | ||
| 644 | 640 | """See Tree.all_file_ids.""" | ||
| 645 | 641 | file_ids = set() | ||
| 646 | 642 | for tree in self._nested_trees.all_trees().itervalues(): | ||
| 647 | 643 | file_ids.update(tree.all_file_ids()) | ||
| 648 | 644 | return file_ids | ||
| 649 | 645 | |||
| 650 | 646 | def is_ignored(self, filename): | ||
| 651 | 647 | """See Tree.is_ignored.""" | ||
| 652 | 648 | tree, prefix, filename = self._nested_trees.get_path_info(filename) | ||
| 653 | 649 | return tree.is_ignored(filename) | ||
| 654 | 650 | |||
| 655 | 651 | def kind(self, file_id): | ||
| 656 | 652 | """See Tree.kind""" | ||
| 657 | 653 | return self._nested_trees.get_tree(file_id).kind(file_id) | ||
| 658 | 654 | |||
| 659 | 655 | def has_filename(self, filename): | ||
| 660 | 656 | """See Tree.has_filename.""" | ||
| 661 | 657 | tree, prefix, filename = self._nested_trees.get_path_info(filename) | ||
| 662 | 658 | return tree.has_filename(filename) | ||
| 663 | 659 | |||
| 664 | 660 | def filter_unversioned_files(self, paths): | ||
| 665 | 661 | """See Tree.filter_unversioned_files.""" | ||
| 666 | 662 | unversioned = set() | ||
| 667 | 663 | for tree, tree_path, subpaths in \ | ||
| 668 | 664 | self._nested_trees.iter_pathinfo_by_tree(paths): | ||
| 669 | 665 | unversioned.update(osutils.pathjoin(tree_path, s) for s | ||
| 670 | 666 | in tree.filter_unversioned_files(subpaths)) | ||
| 671 | 667 | return unversioned | ||
| 672 | 668 | |||
| 673 | 669 | def _comparison_data(self, entry, path): | ||
| 674 | 670 | tree, prefix, path = self._nested_trees.get_path_info(path) | ||
| 675 | 671 | kind, executable, stat = tree._comparison_data(entry, path) | ||
| 676 | 672 | if kind == 'tree-reference': | ||
| 677 | 673 | kind = 'directory' | ||
| 678 | 674 | return kind, executable, stat | ||
| 679 | 675 | |||
| 680 | 676 | def _file_size(self, entry, stat_value): | ||
| 681 | 677 | return self._nested_trees.get_tree(entry.file_id)._file_size( | ||
| 682 | 678 | entry, stat_value) | ||
| 683 | 679 | |||
| 684 | 680 | def get_canonical_inventory_path(self, path): | ||
| 685 | 681 | """See Tree.get_canonical_inventory_path.""" | ||
| 686 | 682 | return self.inventory._get_ci_path_info(path)[0] | ||
| 687 | 683 | |||
| 688 | 684 | def get_canonical_inventory_paths(self, paths): | ||
| 689 | 685 | """See Tree.get_canonical_inventory_paths.""" | ||
| 690 | 686 | return [self.get_canonical_inventory_path(p) for p in paths] | ||
| 691 | 687 | |||
| 692 | 688 | def get_parent_ids(self): | ||
| 693 | 689 | """See Tree.get_parent_ids.""" | ||
| 694 | 690 | return self._nested_trees.root_tree.get_parent_ids() | ||
| 695 | 691 | |||
| 696 | 692 | def get_file_sha1(self, file_id, path=None, stat_value=None): | ||
| 697 | 693 | """See Tree.get_file_sha1.""" | ||
| 698 | 694 | tree, relpath = self._find_tree_path(file_id, path) | ||
| 699 | 695 | return tree.get_file_sha1(file_id, relpath, stat_value) | ||
| 700 | 696 | |||
| 701 | 697 | def get_file_mtime(self, file_id, path=None): | ||
| 702 | 698 | """See Tree.get_file_mtime.""" | ||
| 703 | 699 | tree, relpath = self._find_tree_path(file_id, path) | ||
| 704 | 700 | return tree.get_file_mtime( file_id, relpath) | ||
| 705 | 701 | |||
| 706 | 702 | def get_symlink_target(self, file_id): | ||
| 707 | 703 | """See Tree.get_symlink_target.""" | ||
| 708 | 704 | return self._nested_trees.get_tree(file_id).get_symlink_target(file_id) | ||
| 709 | 705 | |||
| 710 | 706 | def iter_children(self, file_id): | ||
| 711 | 707 | """See Tree.iter_children.""" | ||
| 712 | 708 | tree = self._nested_trees.get_tree_and_treepath(file_id, | ||
| 713 | 709 | skip_references=True)[0] | ||
| 714 | 710 | return tree.iter_children(file_id) | ||
| 715 | 711 | |||
| 716 | 712 | def id2path(self, file_id): | ||
| 717 | 713 | """See Tree.id2path.""" | ||
| 718 | 714 | tree, path = self._nested_trees.get_tree_and_treepath(file_id) | ||
| 719 | 715 | return osutils.pathjoin(path, tree.id2path(file_id)) | ||
| 720 | 716 | |||
| 721 | 717 | def apply_inventory_delta(self, changes): | ||
| 722 | 718 | """Apply an inventory delta to a set of subtrees. | ||
| 723 | 719 | |||
| 724 | 720 | The delta is rewritten into a collection of deltas, one for each | ||
| 725 | 721 | affected subtree, then applied to each. | ||
| 726 | 722 | """ | ||
| 727 | 723 | deltas = {} | ||
| 728 | 724 | for old_path, new_path, file_id, new_entry in changes: | ||
| 729 | 725 | if new_path is not None: | ||
| 730 | 726 | if new_entry.kind == 'tree-reference': | ||
| 731 | 727 | raise ValueError('Cannot introduce or change a' | ||
| 732 | 728 | ' tree-reference in' | ||
| 733 | 729 | ' CompositeTree.apply_inventory_delta.') | ||
| 734 | 730 | new_tree, new_tree_path = \ | ||
| 735 | 731 | self._nested_trees.get_tree_and_treepath( | ||
| 736 | 732 | new_entry.parent_id, skip_references=True) | ||
| 737 | 733 | if new_tree_path != '': | ||
| 738 | 734 | new_path = new_path[len(new_tree_path) + 1:] | ||
| 739 | 735 | else: | ||
| 740 | 736 | new_tree_path = None | ||
| 741 | 737 | if old_path is not None: | ||
| 742 | 738 | old_tree, old_tree_path = \ | ||
| 743 | 739 | self._nested_trees.get_tree_and_treepath(file_id) | ||
| 744 | 740 | if old_tree_path != '': | ||
| 745 | 741 | old_path = old_path[len(old_tree_path) + 1:] | ||
| 746 | 742 | old_tree_delta, old_tree = deltas.setdefault(old_tree_path, | ||
| 747 | 743 | ([], old_tree)) | ||
| 748 | 744 | if old_tree_path == new_tree_path: | ||
| 749 | 745 | old_tree_delta.append((old_path, new_path, file_id, | ||
| 750 | 746 | new_entry)) | ||
| 751 | 747 | else: | ||
| 752 | 748 | old_tree_delta.append((old_path, None, file_id, None)) | ||
| 753 | 749 | else: | ||
| 754 | 750 | old_tree_path = None | ||
| 755 | 751 | if new_path is not None and new_tree_path != old_tree_path: | ||
| 756 | 752 | new_tree_delta, new_tree = deltas.setdefault(new_tree_path, | ||
| 757 | 753 | ([], new_tree)) | ||
| 758 | 754 | new_tree_delta.append((None, new_path, file_id, new_entry)) | ||
| 759 | 755 | for delta, tree in deltas.itervalues(): | ||
| 760 | 756 | tree.apply_inventory_delta(delta) | ||
| 761 | 757 | |||
| 762 | 758 | @property | ||
| 763 | 759 | def case_sensitive(self): | ||
| 764 | 760 | """If True, the underlying filesystem is case sensitive.""" | ||
| 765 | 761 | return self._nested_trees.root_tree.case_sensitive | ||
| 766 | 0 | 762 | ||
| 767 | === modified file 'bzrlib/export/__init__.py' | |||
| 768 | --- bzrlib/export/__init__.py 2009-03-23 14:59:43 +0000 | |||
| 769 | +++ bzrlib/export/__init__.py 2009-08-31 04:38:31 +0000 | |||
| 770 | @@ -146,20 +146,20 @@ | |||
| 771 | 146 | else: | 146 | else: |
| 772 | 147 | subdir_id = inv.path2id(subdir) | 147 | subdir_id = inv.path2id(subdir) |
| 773 | 148 | entries = inv.iter_entries(subdir_id) | 148 | entries = inv.iter_entries(subdir_id) |
| 777 | 149 | if subdir is None: | 149 | for path, entry in entries: |
| 778 | 150 | entries.next() # skip root | 150 | if path == '': |
| 779 | 151 | for entry in entries: | 151 | continue |
| 780 | 152 | # The .bzr* namespace is reserved for "magic" files like | 152 | # The .bzr* namespace is reserved for "magic" files like |
| 781 | 153 | # .bzrignore and .bzrrules - do not export these | 153 | # .bzrignore and .bzrrules - do not export these |
| 783 | 154 | if entry[0].startswith(".bzr"): | 154 | if path.startswith(".bzr"): |
| 784 | 155 | continue | 155 | continue |
| 785 | 156 | if subdir is None: | 156 | if subdir is None: |
| 787 | 157 | if not tree.has_filename(entry[0]): | 157 | if not tree.has_filename(path): |
| 788 | 158 | continue | 158 | continue |
| 789 | 159 | else: | 159 | else: |
| 791 | 160 | if not tree.has_filename(os.path.join(subdir, entry[0])): | 160 | if not tree.has_filename(os.path.join(subdir, path)): |
| 792 | 161 | continue | 161 | continue |
| 794 | 162 | yield entry | 162 | yield path, entry |
| 795 | 163 | 163 | ||
| 796 | 164 | 164 | ||
| 797 | 165 | register_lazy_exporter(None, [], 'bzrlib.export.dir_exporter', 'dir_exporter') | 165 | register_lazy_exporter(None, [], 'bzrlib.export.dir_exporter', 'dir_exporter') |
| 798 | 166 | 166 | ||
| 799 | === modified file 'bzrlib/revisiontree.py' | |||
| 800 | --- bzrlib/revisiontree.py 2009-08-28 05:00:33 +0000 | |||
| 801 | +++ bzrlib/revisiontree.py 2009-08-31 04:38:31 +0000 | |||
| 802 | @@ -140,6 +140,9 @@ | |||
| 803 | 140 | def get_reference_revision(self, file_id, path=None): | 140 | def get_reference_revision(self, file_id, path=None): |
| 804 | 141 | return self.inventory[file_id].reference_revision | 141 | return self.inventory[file_id].reference_revision |
| 805 | 142 | 142 | ||
| 806 | 143 | def get_nested_tree(self, file_id, branch, path=None): | ||
| 807 | 144 | return self._get_nested_revision_tree(file_id, branch, path) | ||
| 808 | 145 | |||
| 809 | 143 | def get_root_id(self): | 146 | def get_root_id(self): |
| 810 | 144 | if self.inventory.root: | 147 | if self.inventory.root: |
| 811 | 145 | return self.inventory.root.file_id | 148 | return self.inventory.root.file_id |
| 812 | 146 | 149 | ||
| 813 | === modified file 'bzrlib/tests/__init__.py' | |||
| 814 | --- bzrlib/tests/__init__.py 2009-08-28 21:05:31 +0000 | |||
| 815 | +++ bzrlib/tests/__init__.py 2009-08-31 04:38:32 +0000 | |||
| 816 | @@ -3697,6 +3697,183 @@ | |||
| 817 | 3697 | This function can be replaced if you need to change the default test | 3697 | This function can be replaced if you need to change the default test |
| 818 | 3698 | suite on a global basis, but it is not encouraged. | 3698 | suite on a global basis, but it is not encouraged. |
| 819 | 3699 | """ | 3699 | """ |
| 820 | 3700 | <<<<<<< TREE | ||
| 821 | 3701 | ======= | ||
| 822 | 3702 | testmod_names = [ | ||
| 823 | 3703 | 'bzrlib.doc', | ||
| 824 | 3704 | 'bzrlib.tests.blackbox', | ||
| 825 | 3705 | 'bzrlib.tests.branch_implementations', | ||
| 826 | 3706 | 'bzrlib.tests.bzrdir_implementations', | ||
| 827 | 3707 | 'bzrlib.tests.commands', | ||
| 828 | 3708 | 'bzrlib.tests.interrepository_implementations', | ||
| 829 | 3709 | 'bzrlib.tests.intertree_implementations', | ||
| 830 | 3710 | 'bzrlib.tests.inventory_implementations', | ||
| 831 | 3711 | 'bzrlib.tests.per_interbranch', | ||
| 832 | 3712 | 'bzrlib.tests.per_lock', | ||
| 833 | 3713 | 'bzrlib.tests.per_repository', | ||
| 834 | 3714 | 'bzrlib.tests.per_repository_chk', | ||
| 835 | 3715 | 'bzrlib.tests.per_repository_reference', | ||
| 836 | 3716 | 'bzrlib.tests.test__chk_map', | ||
| 837 | 3717 | 'bzrlib.tests.test__dirstate_helpers', | ||
| 838 | 3718 | 'bzrlib.tests.test__groupcompress', | ||
| 839 | 3719 | 'bzrlib.tests.test__walkdirs_win32', | ||
| 840 | 3720 | 'bzrlib.tests.test_ancestry', | ||
| 841 | 3721 | 'bzrlib.tests.test_annotate', | ||
| 842 | 3722 | 'bzrlib.tests.test_api', | ||
| 843 | 3723 | 'bzrlib.tests.test_atomicfile', | ||
| 844 | 3724 | 'bzrlib.tests.test_bad_files', | ||
| 845 | 3725 | 'bzrlib.tests.test_bisect_multi', | ||
| 846 | 3726 | 'bzrlib.tests.test_branch', | ||
| 847 | 3727 | 'bzrlib.tests.test_branchbuilder', | ||
| 848 | 3728 | 'bzrlib.tests.test_btree_index', | ||
| 849 | 3729 | 'bzrlib.tests.test_bugtracker', | ||
| 850 | 3730 | 'bzrlib.tests.test_bundle', | ||
| 851 | 3731 | 'bzrlib.tests.test_bzrdir', | ||
| 852 | 3732 | 'bzrlib.tests.test__chunks_to_lines', | ||
| 853 | 3733 | 'bzrlib.tests.test_cache_utf8', | ||
| 854 | 3734 | 'bzrlib.tests.test_chk_map', | ||
| 855 | 3735 | 'bzrlib.tests.test_chunk_writer', | ||
| 856 | 3736 | 'bzrlib.tests.test_clean_tree', | ||
| 857 | 3737 | 'bzrlib.tests.test_commands', | ||
| 858 | 3738 | 'bzrlib.tests.test_commit', | ||
| 859 | 3739 | 'bzrlib.tests.test_commit_merge', | ||
| 860 | 3740 | 'bzrlib.tests.test_composite_tree', | ||
| 861 | 3741 | 'bzrlib.tests.test_config', | ||
| 862 | 3742 | 'bzrlib.tests.test_conflicts', | ||
| 863 | 3743 | 'bzrlib.tests.test_counted_lock', | ||
| 864 | 3744 | 'bzrlib.tests.test_decorators', | ||
| 865 | 3745 | 'bzrlib.tests.test_delta', | ||
| 866 | 3746 | 'bzrlib.tests.test_debug', | ||
| 867 | 3747 | 'bzrlib.tests.test_deprecated_graph', | ||
| 868 | 3748 | 'bzrlib.tests.test_diff', | ||
| 869 | 3749 | 'bzrlib.tests.test_directory_service', | ||
| 870 | 3750 | 'bzrlib.tests.test_dirstate', | ||
| 871 | 3751 | 'bzrlib.tests.test_email_message', | ||
| 872 | 3752 | 'bzrlib.tests.test_eol_filters', | ||
| 873 | 3753 | 'bzrlib.tests.test_errors', | ||
| 874 | 3754 | 'bzrlib.tests.test_export', | ||
| 875 | 3755 | 'bzrlib.tests.test_extract', | ||
| 876 | 3756 | 'bzrlib.tests.test_fetch', | ||
| 877 | 3757 | 'bzrlib.tests.test_fifo_cache', | ||
| 878 | 3758 | 'bzrlib.tests.test_filters', | ||
| 879 | 3759 | 'bzrlib.tests.test_ftp_transport', | ||
| 880 | 3760 | 'bzrlib.tests.test_foreign', | ||
| 881 | 3761 | 'bzrlib.tests.test_generate_docs', | ||
| 882 | 3762 | 'bzrlib.tests.test_generate_ids', | ||
| 883 | 3763 | 'bzrlib.tests.test_globbing', | ||
| 884 | 3764 | 'bzrlib.tests.test_gpg', | ||
| 885 | 3765 | 'bzrlib.tests.test_graph', | ||
| 886 | 3766 | 'bzrlib.tests.test_groupcompress', | ||
| 887 | 3767 | 'bzrlib.tests.test_hashcache', | ||
| 888 | 3768 | 'bzrlib.tests.test_help', | ||
| 889 | 3769 | 'bzrlib.tests.test_hooks', | ||
| 890 | 3770 | 'bzrlib.tests.test_http', | ||
| 891 | 3771 | 'bzrlib.tests.test_http_implementations', | ||
| 892 | 3772 | 'bzrlib.tests.test_http_response', | ||
| 893 | 3773 | 'bzrlib.tests.test_https_ca_bundle', | ||
| 894 | 3774 | 'bzrlib.tests.test_identitymap', | ||
| 895 | 3775 | 'bzrlib.tests.test_ignores', | ||
| 896 | 3776 | 'bzrlib.tests.test_index', | ||
| 897 | 3777 | 'bzrlib.tests.test_info', | ||
| 898 | 3778 | 'bzrlib.tests.test_inv', | ||
| 899 | 3779 | 'bzrlib.tests.test_inventory_delta', | ||
| 900 | 3780 | 'bzrlib.tests.test_knit', | ||
| 901 | 3781 | 'bzrlib.tests.test_lazy_import', | ||
| 902 | 3782 | 'bzrlib.tests.test_lazy_regex', | ||
| 903 | 3783 | 'bzrlib.tests.test_lockable_files', | ||
| 904 | 3784 | 'bzrlib.tests.test_lockdir', | ||
| 905 | 3785 | 'bzrlib.tests.test_log', | ||
| 906 | 3786 | 'bzrlib.tests.test_lru_cache', | ||
| 907 | 3787 | 'bzrlib.tests.test_lsprof', | ||
| 908 | 3788 | 'bzrlib.tests.test_mail_client', | ||
| 909 | 3789 | 'bzrlib.tests.test_memorytree', | ||
| 910 | 3790 | 'bzrlib.tests.test_merge', | ||
| 911 | 3791 | 'bzrlib.tests.test_merge3', | ||
| 912 | 3792 | 'bzrlib.tests.test_merge_core', | ||
| 913 | 3793 | 'bzrlib.tests.test_merge_directive', | ||
| 914 | 3794 | 'bzrlib.tests.test_missing', | ||
| 915 | 3795 | 'bzrlib.tests.test_msgeditor', | ||
| 916 | 3796 | 'bzrlib.tests.test_multiparent', | ||
| 917 | 3797 | 'bzrlib.tests.test_mutabletree', | ||
| 918 | 3798 | 'bzrlib.tests.test_nonascii', | ||
| 919 | 3799 | 'bzrlib.tests.test_options', | ||
| 920 | 3800 | 'bzrlib.tests.test_osutils', | ||
| 921 | 3801 | 'bzrlib.tests.test_osutils_encodings', | ||
| 922 | 3802 | 'bzrlib.tests.test_pack', | ||
| 923 | 3803 | 'bzrlib.tests.test_pack_repository', | ||
| 924 | 3804 | 'bzrlib.tests.test_patch', | ||
| 925 | 3805 | 'bzrlib.tests.test_patches', | ||
| 926 | 3806 | 'bzrlib.tests.test_permissions', | ||
| 927 | 3807 | 'bzrlib.tests.test_plugins', | ||
| 928 | 3808 | 'bzrlib.tests.test_progress', | ||
| 929 | 3809 | 'bzrlib.tests.test_read_bundle', | ||
| 930 | 3810 | 'bzrlib.tests.test_reconcile', | ||
| 931 | 3811 | 'bzrlib.tests.test_reconfigure', | ||
| 932 | 3812 | 'bzrlib.tests.test_registry', | ||
| 933 | 3813 | 'bzrlib.tests.test_remote', | ||
| 934 | 3814 | 'bzrlib.tests.test_rename_map', | ||
| 935 | 3815 | 'bzrlib.tests.test_repository', | ||
| 936 | 3816 | 'bzrlib.tests.test_revert', | ||
| 937 | 3817 | 'bzrlib.tests.test_revision', | ||
| 938 | 3818 | 'bzrlib.tests.test_revisionspec', | ||
| 939 | 3819 | 'bzrlib.tests.test_revisiontree', | ||
| 940 | 3820 | 'bzrlib.tests.test_rio', | ||
| 941 | 3821 | 'bzrlib.tests.test_rules', | ||
| 942 | 3822 | 'bzrlib.tests.test_sampler', | ||
| 943 | 3823 | 'bzrlib.tests.test_selftest', | ||
| 944 | 3824 | 'bzrlib.tests.test_serializer', | ||
| 945 | 3825 | 'bzrlib.tests.test_setup', | ||
| 946 | 3826 | 'bzrlib.tests.test_sftp_transport', | ||
| 947 | 3827 | 'bzrlib.tests.test_shelf', | ||
| 948 | 3828 | 'bzrlib.tests.test_shelf_ui', | ||
| 949 | 3829 | 'bzrlib.tests.test_smart', | ||
| 950 | 3830 | 'bzrlib.tests.test_smart_add', | ||
| 951 | 3831 | 'bzrlib.tests.test_smart_request', | ||
| 952 | 3832 | 'bzrlib.tests.test_smart_transport', | ||
| 953 | 3833 | 'bzrlib.tests.test_smtp_connection', | ||
| 954 | 3834 | 'bzrlib.tests.test_source', | ||
| 955 | 3835 | 'bzrlib.tests.test_ssh_transport', | ||
| 956 | 3836 | 'bzrlib.tests.test_status', | ||
| 957 | 3837 | 'bzrlib.tests.test_store', | ||
| 958 | 3838 | 'bzrlib.tests.test_strace', | ||
| 959 | 3839 | 'bzrlib.tests.test_subsume', | ||
| 960 | 3840 | 'bzrlib.tests.test_switch', | ||
| 961 | 3841 | 'bzrlib.tests.test_symbol_versioning', | ||
| 962 | 3842 | 'bzrlib.tests.test_tag', | ||
| 963 | 3843 | 'bzrlib.tests.test_testament', | ||
| 964 | 3844 | 'bzrlib.tests.test_textfile', | ||
| 965 | 3845 | 'bzrlib.tests.test_textmerge', | ||
| 966 | 3846 | 'bzrlib.tests.test_timestamp', | ||
| 967 | 3847 | 'bzrlib.tests.test_trace', | ||
| 968 | 3848 | 'bzrlib.tests.test_transactions', | ||
| 969 | 3849 | 'bzrlib.tests.test_transform', | ||
| 970 | 3850 | 'bzrlib.tests.test_transport', | ||
| 971 | 3851 | 'bzrlib.tests.test_transport_implementations', | ||
| 972 | 3852 | 'bzrlib.tests.test_transport_log', | ||
| 973 | 3853 | 'bzrlib.tests.test_tree', | ||
| 974 | 3854 | 'bzrlib.tests.test_treebuilder', | ||
| 975 | 3855 | 'bzrlib.tests.test_tsort', | ||
| 976 | 3856 | 'bzrlib.tests.test_tuned_gzip', | ||
| 977 | 3857 | 'bzrlib.tests.test_ui', | ||
| 978 | 3858 | 'bzrlib.tests.test_uncommit', | ||
| 979 | 3859 | 'bzrlib.tests.test_upgrade', | ||
| 980 | 3860 | 'bzrlib.tests.test_upgrade_stacked', | ||
| 981 | 3861 | 'bzrlib.tests.test_urlutils', | ||
| 982 | 3862 | 'bzrlib.tests.test_version', | ||
| 983 | 3863 | 'bzrlib.tests.test_version_info', | ||
| 984 | 3864 | 'bzrlib.tests.test_versionedfile', | ||
| 985 | 3865 | 'bzrlib.tests.test_weave', | ||
| 986 | 3866 | 'bzrlib.tests.test_whitebox', | ||
| 987 | 3867 | 'bzrlib.tests.test_win32utils', | ||
| 988 | 3868 | 'bzrlib.tests.test_workingtree', | ||
| 989 | 3869 | 'bzrlib.tests.test_workingtree_4', | ||
| 990 | 3870 | 'bzrlib.tests.test_wsgi', | ||
| 991 | 3871 | 'bzrlib.tests.test_xml', | ||
| 992 | 3872 | 'bzrlib.tests.tree_implementations', | ||
| 993 | 3873 | 'bzrlib.tests.workingtree_implementations', | ||
| 994 | 3874 | 'bzrlib.util.tests.test_bencode', | ||
| 995 | 3875 | ] | ||
| 996 | 3876 | >>>>>>> MERGE-SOURCE | ||
| 997 | 3700 | 3877 | ||
| 998 | 3701 | loader = TestUtil.TestLoader() | 3878 | loader = TestUtil.TestLoader() |
| 999 | 3702 | 3879 | ||
| 1000 | 3703 | 3880 | ||
| 1001 | === modified file 'bzrlib/tests/per_workingtree/test_add_reference.py' | |||
| 1002 | --- bzrlib/tests/per_workingtree/test_add_reference.py 2009-07-10 07:14:02 +0000 | |||
| 1003 | +++ bzrlib/tests/per_workingtree/test_add_reference.py 2009-08-31 04:38:32 +0000 | |||
| 1004 | @@ -63,7 +63,8 @@ | |||
| 1005 | 63 | basis = tree.basis_tree() | 63 | basis = tree.basis_tree() |
| 1006 | 64 | basis.lock_read() | 64 | basis.lock_read() |
| 1007 | 65 | try: | 65 | try: |
| 1009 | 66 | sub_tree = tree.get_nested_tree('sub-tree-root-id') | 66 | sub_tree = tree.get_nested_tree('sub-tree-root-id', |
| 1010 | 67 | tree.branch) | ||
| 1011 | 67 | self.assertEqual(sub_tree.last_revision(), | 68 | self.assertEqual(sub_tree.last_revision(), |
| 1012 | 68 | tree.get_reference_revision('sub-tree-root-id')) | 69 | tree.get_reference_revision('sub-tree-root-id')) |
| 1013 | 69 | finally: | 70 | finally: |
| 1014 | @@ -108,8 +109,9 @@ | |||
| 1015 | 108 | tree, sub_tree = self.make_nested_trees() | 109 | tree, sub_tree = self.make_nested_trees() |
| 1016 | 109 | tree.lock_read() | 110 | tree.lock_read() |
| 1017 | 110 | try: | 111 | try: |
| 1019 | 111 | sub_tree2 = tree.get_nested_tree('sub-tree-root-id') | 112 | sub_tree2 = tree.get_nested_tree('sub-tree-root-id', tree.branch) |
| 1020 | 112 | self.assertEqual(sub_tree.basedir, sub_tree2.basedir) | 113 | self.assertEqual(sub_tree.basedir, sub_tree2.basedir) |
| 1022 | 113 | sub_tree2 = tree.get_nested_tree('sub-tree-root-id', 'sub-tree') | 114 | sub_tree2 = tree.get_nested_tree('sub-tree-root-id', tree.branch, |
| 1023 | 115 | 'sub-tree') | ||
| 1024 | 114 | finally: | 116 | finally: |
| 1025 | 115 | tree.unlock() | 117 | tree.unlock() |
| 1026 | 116 | 118 | ||
| 1027 | === added file 'bzrlib/tests/test_composite_tree.py' | |||
| 1028 | --- bzrlib/tests/test_composite_tree.py 1970-01-01 00:00:00 +0000 | |||
| 1029 | +++ bzrlib/tests/test_composite_tree.py 2009-08-31 04:38:32 +0000 | |||
| 1030 | @@ -0,0 +1,362 @@ | |||
| 1031 | 1 | # Copyright (C) 2007, 2009 Canonical Ltd | ||
| 1032 | 2 | # | ||
| 1033 | 3 | # This program is free software; you can redistribute it and/or modify | ||
| 1034 | 4 | # it under the terms of the GNU General Public License as published by | ||
| 1035 | 5 | # the Free Software Foundation; either version 2 of the License, or | ||
| 1036 | 6 | # (at your option) any later version. | ||
| 1037 | 7 | # | ||
| 1038 | 8 | # This program is distributed in the hope that it will be useful, | ||
| 1039 | 9 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 1040 | 10 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| 1041 | 11 | # GNU General Public License for more details. | ||
| 1042 | 12 | # | ||
| 1043 | 13 | # You should have received a copy of the GNU General Public License | ||
| 1044 | 14 | # along with this program; if not, write to the Free Software | ||
| 1045 | 15 | # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
| 1046 | 16 | |||
| 1047 | 17 | |||
| 1048 | 18 | import os | ||
| 1049 | 19 | |||
| 1050 | 20 | from bzrlib import ( | ||
| 1051 | 21 | composite_tree, | ||
| 1052 | 22 | conflicts, | ||
| 1053 | 23 | errors, | ||
| 1054 | 24 | inventory, | ||
| 1055 | 25 | tests, | ||
| 1056 | 26 | ) | ||
| 1057 | 27 | from bzrlib.export import export | ||
| 1058 | 28 | |||
| 1059 | 29 | |||
| 1060 | 30 | class TestNestedTrees(tests.TestCaseWithTransport): | ||
| 1061 | 31 | |||
| 1062 | 32 | def make_branch_and_tree(self, path, format='pack-0.92-subtree'): | ||
| 1063 | 33 | return tests.TestCaseWithTransport.make_branch_and_tree( | ||
| 1064 | 34 | self, path, format) | ||
| 1065 | 35 | |||
| 1066 | 36 | def test_paths_info(self): | ||
| 1067 | 37 | tree = self.make_branch_and_tree('.') | ||
| 1068 | 38 | subtree = self.make_branch_and_tree('sub') | ||
| 1069 | 39 | subsubtree = self.make_branch_and_tree('sub/sub') | ||
| 1070 | 40 | subsubtree.set_root_id('sub-sub-root-id') | ||
| 1071 | 41 | subtree.add_reference(subsubtree) | ||
| 1072 | 42 | tree.add_reference(subtree) | ||
| 1073 | 43 | nested = composite_tree.NestedTrees(tree, tree.branch) | ||
| 1074 | 44 | nested.lock_read() | ||
| 1075 | 45 | self.addCleanup(nested.unlock) | ||
| 1076 | 46 | fullpath, relpath, found_entry, found_tree = \ | ||
| 1077 | 47 | nested.paths_info(['sub/sub'])[0] | ||
| 1078 | 48 | self.assertEqual('sub-sub-root-id', found_entry.file_id) | ||
| 1079 | 49 | self.assertEqual(subsubtree.basedir, found_tree.basedir) | ||
| 1080 | 50 | self.assertEqual('', relpath) | ||
| 1081 | 51 | self.assertEqual('sub/sub', fullpath) | ||
| 1082 | 52 | |||
| 1083 | 53 | # Now testing an unversioned, non-existent path | ||
| 1084 | 54 | fullpath, relpath, found_entry, found_tree = \ | ||
| 1085 | 55 | nested.paths_info(['sub/subb'])[0] | ||
| 1086 | 56 | self.assertIs(None, found_entry) | ||
| 1087 | 57 | self.assertIsNot(None, found_tree) | ||
| 1088 | 58 | |||
| 1089 | 59 | def lock_read(self, item): | ||
| 1090 | 60 | item.lock_read() | ||
| 1091 | 61 | self.addCleanup(item.unlock) | ||
| 1092 | 62 | |||
| 1093 | 63 | def test_all_trees(self): | ||
| 1094 | 64 | tree = self.make_branch_and_tree('tree') | ||
| 1095 | 65 | subtree = self.make_branch_and_tree('tree/subtree') | ||
| 1096 | 66 | tree.add_reference(subtree) | ||
| 1097 | 67 | subsubtree = self.make_branch_and_tree('tree/subtree/subsubtree') | ||
| 1098 | 68 | subtree.add_reference(subsubtree) | ||
| 1099 | 69 | nested = composite_tree.NestedTrees(tree, tree.branch) | ||
| 1100 | 70 | self.lock_read(nested) | ||
| 1101 | 71 | result = nested.all_trees() | ||
| 1102 | 72 | expected = {'': tree, 'subtree': subtree, | ||
| 1103 | 73 | 'subtree/subsubtree': subsubtree} | ||
| 1104 | 74 | def bases(input): | ||
| 1105 | 75 | return dict((y, x.basedir) for y, x in input.iteritems()) | ||
| 1106 | 76 | self.assertEqual(bases(expected), bases(result)) | ||
| 1107 | 77 | |||
| 1108 | 78 | |||
| 1109 | 79 | class TestCompositeTree(tests.TestCaseWithTransport): | ||
| 1110 | 80 | |||
| 1111 | 81 | def make_branch_and_tree(self, path, format='pack-0.92-subtree'): | ||
| 1112 | 82 | return tests.TestCaseWithTransport.make_branch_and_tree( | ||
| 1113 | 83 | self, path, format) | ||
| 1114 | 84 | |||
| 1115 | 85 | def make_tree_files(self, subfile=False): | ||
| 1116 | 86 | tree = self.make_branch_and_tree('.') | ||
| 1117 | 87 | self.build_tree(['file']) | ||
| 1118 | 88 | tree.set_root_id('tree-root') | ||
| 1119 | 89 | tree.add(['file'], ['file-id']) | ||
| 1120 | 90 | subtree = self.make_branch_and_tree('subtree') | ||
| 1121 | 91 | subtree.set_root_id('subtree-id') | ||
| 1122 | 92 | if subfile: | ||
| 1123 | 93 | self.build_tree(['subtree/subfile']) | ||
| 1124 | 94 | subtree.add('subfile', 'subfile-id') | ||
| 1125 | 95 | tree.add_reference(subtree) | ||
| 1126 | 96 | tree.lock_write() | ||
| 1127 | 97 | self.addCleanup(tree.unlock) | ||
| 1128 | 98 | return tree, subtree | ||
| 1129 | 99 | |||
| 1130 | 100 | def test_move_across_trees(self): | ||
| 1131 | 101 | tree, subtree = self.make_tree_files() | ||
| 1132 | 102 | composite = composite_tree.CompositeTree(tree, tree.branch) | ||
| 1133 | 103 | pairs = composite.move(['file'], 'subtree') | ||
| 1134 | 104 | subtree.lock_write() | ||
| 1135 | 105 | self.addCleanup(subtree.unlock) | ||
| 1136 | 106 | self.assertIs(None, tree.path2id('file')) | ||
| 1137 | 107 | self.assertEqual('file-id', subtree.path2id('file')) | ||
| 1138 | 108 | self.failUnlessExists('subtree/file') | ||
| 1139 | 109 | self.failIfExists('file') | ||
| 1140 | 110 | self.assertEqual([('file', 'subtree/file')], pairs) | ||
| 1141 | 111 | |||
| 1142 | 112 | def test_move_after(self): | ||
| 1143 | 113 | tree, subtree = self.make_tree_files() | ||
| 1144 | 114 | os.rename('file', 'subtree/file') | ||
| 1145 | 115 | composite = composite_tree.CompositeTree(tree, tree.branch) | ||
| 1146 | 116 | composite.move(['file'], 'subtree', after=True) | ||
| 1147 | 117 | self.assertIs(None, tree.path2id('file')) | ||
| 1148 | 118 | self.assertEqual('file-id', subtree.path2id('file')) | ||
| 1149 | 119 | |||
| 1150 | 120 | def test_move_needs_after(self): | ||
| 1151 | 121 | tree, subtree = self.make_tree_files() | ||
| 1152 | 122 | self.build_tree(['subtree/file']) | ||
| 1153 | 123 | composite = composite_tree.CompositeTree(tree, tree.branch) | ||
| 1154 | 124 | self.assertRaises(errors.RenameFailedFilesExist, composite.move, | ||
| 1155 | 125 | ['file'], 'subtree') | ||
| 1156 | 126 | |||
| 1157 | 127 | def test_move_force_after(self): | ||
| 1158 | 128 | tree, subtree = self.make_tree_files() | ||
| 1159 | 129 | self.build_tree(['subtree/file']) | ||
| 1160 | 130 | composite = composite_tree.CompositeTree(tree, tree.branch) | ||
| 1161 | 131 | composite.move(['file'], 'subtree', | ||
| 1162 | 132 | after=True) | ||
| 1163 | 133 | self.assertIs(None, tree.path2id('file')) | ||
| 1164 | 134 | self.assertEqual('file-id', subtree.path2id('file')) | ||
| 1165 | 135 | |||
| 1166 | 136 | def test_move_to_unversioned(self): | ||
| 1167 | 137 | tree, subtree = self.make_tree_files() | ||
| 1168 | 138 | tree.remove('subtree') | ||
| 1169 | 139 | composite = composite_tree.CompositeTree(tree, tree.branch) | ||
| 1170 | 140 | self.assertRaises(errors.BzrMoveFailedError, composite.move, ['file'], | ||
| 1171 | 141 | 'subtree', after=True) | ||
| 1172 | 142 | |||
| 1173 | 143 | def test_move_from_unversioned(self): | ||
| 1174 | 144 | tree, subtree = self.make_tree_files() | ||
| 1175 | 145 | tree.remove('file') | ||
| 1176 | 146 | composite = composite_tree.CompositeTree(tree, tree.branch) | ||
| 1177 | 147 | self.assertRaises(errors.BzrMoveFailedError, composite.move, ['file'], | ||
| 1178 | 148 | 'subtree', after=True) | ||
| 1179 | 149 | |||
| 1180 | 150 | def test_rename_into_subtree(self): | ||
| 1181 | 151 | tree, subtree = self.make_tree_files() | ||
| 1182 | 152 | composite = composite_tree.CompositeTree(tree, tree.branch) | ||
| 1183 | 153 | composite.rename_one('file', 'subtree/file1') | ||
| 1184 | 154 | self.failUnlessExists('subtree/file1') | ||
| 1185 | 155 | self.assertEqual('file-id', subtree.path2id('file1')) | ||
| 1186 | 156 | |||
| 1187 | 157 | def test_iter_entries_by_dir(self): | ||
| 1188 | 158 | tree, subtree = self.make_tree_files() | ||
| 1189 | 159 | composite = self.get_locked_composite(tree) | ||
| 1190 | 160 | for path, entry in composite.iter_entries_by_dir(): | ||
| 1191 | 161 | self.assertNotContainsRe(path, '/$') | ||
| 1192 | 162 | |||
| 1193 | 163 | def test_iter_entries_by_dir_follow_subtree(self): | ||
| 1194 | 164 | """Ensure that iter_entries_by_dir follows subtrees. | ||
| 1195 | 165 | |||
| 1196 | 166 | This makes sure that even when the cached kind is directory, subtree | ||
| 1197 | 167 | is followed. | ||
| 1198 | 168 | """ | ||
| 1199 | 169 | tree = self.make_branch_and_tree('.') | ||
| 1200 | 170 | self.build_tree(['subtree/', 'subtree/file']) | ||
| 1201 | 171 | subtree = self.make_branch_and_tree('subtree') | ||
| 1202 | 172 | self.build_tree(['subtree/file']) | ||
| 1203 | 173 | subtree.add('file') | ||
| 1204 | 174 | tree.add_reference(subtree) | ||
| 1205 | 175 | composite = self.get_locked_composite(tree) | ||
| 1206 | 176 | paths = [p for p, e in composite.iter_entries_by_dir()] | ||
| 1207 | 177 | self.assertTrue('subtree' in paths) | ||
| 1208 | 178 | self.assertTrue('subtree/file' in paths) | ||
| 1209 | 179 | |||
| 1210 | 180 | def test_iter_changes(self): | ||
| 1211 | 181 | tree, subtree = self.make_tree_files() | ||
| 1212 | 182 | new = self.get_locked_composite(tree) | ||
| 1213 | 183 | old = self.get_locked_composite(tree.basis_tree(), tree.branch) | ||
| 1214 | 184 | for file_id, paths, content, versioned, parent, name, kind, executable\ | ||
| 1215 | 185 | in new.iter_changes(old): | ||
| 1216 | 186 | self.assertNotEqual('tree-reference', kind[1]) | ||
| 1217 | 187 | |||
| 1218 | 188 | def test_iter_changes_accepts_specific_files_for_deletion(self): | ||
| 1219 | 189 | """Test corner case requiring all_file_ids()""" | ||
| 1220 | 190 | tree, subtree = self.make_tree_files() | ||
| 1221 | 191 | old = self.get_locked_composite(tree) | ||
| 1222 | 192 | new = self.get_locked_composite(tree.basis_tree(), tree.branch) | ||
| 1223 | 193 | for file_id, paths, content, versioned, parent, name, kind, executable\ | ||
| 1224 | 194 | in new.iter_changes(old, specific_files=['subtree']): | ||
| 1225 | 195 | self.assertNotEqual('tree-reference', kind[1]) | ||
| 1226 | 196 | |||
| 1227 | 197 | def test_inventory(self): | ||
| 1228 | 198 | tree, subtree = self.make_tree_files() | ||
| 1229 | 199 | composite = self.get_locked_composite(tree) | ||
| 1230 | 200 | self.assertRaises(errors.NoSuchId, lambda x: composite.inventory[x], | ||
| 1231 | 201 | 'not-present') | ||
| 1232 | 202 | subtree_entry = composite.inventory['subtree-id'] | ||
| 1233 | 203 | self.assertEqual('tree-reference', subtree_entry.kind) | ||
| 1234 | 204 | |||
| 1235 | 205 | def test_comparison_data(self): | ||
| 1236 | 206 | tree, subtree = self.make_tree_files() | ||
| 1237 | 207 | composite = self.get_locked_composite(tree) | ||
| 1238 | 208 | entry = composite.inventory['subtree-id'] | ||
| 1239 | 209 | kind, exe, stat = composite._comparison_data(entry, 'subtree') | ||
| 1240 | 210 | self.assertEqual('directory', kind) | ||
| 1241 | 211 | |||
| 1242 | 212 | def test_apply_inventory_delta(self): | ||
| 1243 | 213 | tree, subtree = self.make_tree_files() | ||
| 1244 | 214 | composite = composite_tree.CompositeTree(tree, tree.branch) | ||
| 1245 | 215 | # Move an existing file into a new subtree. | ||
| 1246 | 216 | new_entry = tree.inventory['file-id'].copy() | ||
| 1247 | 217 | new_entry.parent_id = 'subtree-id' | ||
| 1248 | 218 | composite.lock_write() | ||
| 1249 | 219 | try: | ||
| 1250 | 220 | composite.apply_inventory_delta([('file', 'subtree/file', | ||
| 1251 | 221 | 'file-id', new_entry)]) | ||
| 1252 | 222 | finally: | ||
| 1253 | 223 | composite.unlock() | ||
| 1254 | 224 | self.assertEqual('file', subtree.id2path('file-id')) | ||
| 1255 | 225 | self.assertEqual('file-id', subtree.path2id('file')) | ||
| 1256 | 226 | self.assertEqual(None, tree.path2id('file')) | ||
| 1257 | 227 | |||
| 1258 | 228 | # Rename subtree/file to subtree/smile | ||
| 1259 | 229 | new_entry = new_entry.copy() | ||
| 1260 | 230 | new_entry.name = 'smile' | ||
| 1261 | 231 | composite.lock_write() | ||
| 1262 | 232 | try: | ||
| 1263 | 233 | composite.apply_inventory_delta([('subtree/file', 'subtree/smile', | ||
| 1264 | 234 | 'file-id', new_entry)]) | ||
| 1265 | 235 | finally: | ||
| 1266 | 236 | composite.unlock() | ||
| 1267 | 237 | self.assertEqual('file-id', subtree.path2id('smile')) | ||
| 1268 | 238 | |||
| 1269 | 239 | # Delete subtree/smile | ||
| 1270 | 240 | composite.lock_write() | ||
| 1271 | 241 | try: | ||
| 1272 | 242 | composite.apply_inventory_delta([('subtree/smile', None, 'file-id', | ||
| 1273 | 243 | None)]) | ||
| 1274 | 244 | finally: | ||
| 1275 | 245 | composite.unlock() | ||
| 1276 | 246 | self.assertEqual(None, subtree.path2id('smile')) | ||
| 1277 | 247 | |||
| 1278 | 248 | # Create subtree/smile | ||
| 1279 | 249 | composite.lock_write() | ||
| 1280 | 250 | try: | ||
| 1281 | 251 | composite.apply_inventory_delta([(None, 'subtree/smile', 'file-id', | ||
| 1282 | 252 | new_entry)]) | ||
| 1283 | 253 | finally: | ||
| 1284 | 254 | composite.unlock() | ||
| 1285 | 255 | self.assertEqual('file-id', subtree.path2id('smile')) | ||
| 1286 | 256 | |||
| 1287 | 257 | # Move subtree/smile back into root tree | ||
| 1288 | 258 | new_entry = new_entry.copy() | ||
| 1289 | 259 | new_entry.parent_id = tree.get_root_id() | ||
| 1290 | 260 | composite.lock_write() | ||
| 1291 | 261 | try: | ||
| 1292 | 262 | composite.apply_inventory_delta([('subtree/smile', 'smile', | ||
| 1293 | 263 | 'file-id', new_entry)]) | ||
| 1294 | 264 | finally: | ||
| 1295 | 265 | composite.unlock() | ||
| 1296 | 266 | self.assertEqual(None, subtree.path2id('smile')) | ||
| 1297 | 267 | self.assertEqual('file-id', tree.path2id('smile')) | ||
| 1298 | 268 | |||
| 1299 | 269 | def test_apply_inventory_delta_tree_reference(self): | ||
| 1300 | 270 | tree = self.make_branch_and_tree('.') | ||
| 1301 | 271 | tree.set_root_id('root-id') | ||
| 1302 | 272 | composite = composite_tree.CompositeTree(tree, tree.branch) | ||
| 1303 | 273 | composite.lock_write() | ||
| 1304 | 274 | self.addCleanup(composite.unlock) | ||
| 1305 | 275 | foo = inventory.TreeReference( | ||
| 1306 | 276 | 'foo-id', 'foo', 'root-id', reference_revision='foo-rev-id') | ||
| 1307 | 277 | e = self.assertRaises(ValueError, composite.apply_inventory_delta, | ||
| 1308 | 278 | [(None, 'foo', 'foo-id', foo)]) | ||
| 1309 | 279 | self.assertEqual('Cannot introduce or change a tree-reference in' | ||
| 1310 | 280 | ' CompositeTree.apply_inventory_delta.', str(e)) | ||
| 1311 | 281 | |||
| 1312 | 282 | def get_locked_composite(self, tree, branch=None): | ||
| 1313 | 283 | if branch is None: | ||
| 1314 | 284 | branch = tree.branch | ||
| 1315 | 285 | composite = composite_tree.CompositeTree(tree, branch) | ||
| 1316 | 286 | composite.lock_read() | ||
| 1317 | 287 | self.addCleanup(composite.unlock) | ||
| 1318 | 288 | return composite | ||
| 1319 | 289 | |||
| 1320 | 290 | def test_all_file_ids(self): | ||
| 1321 | 291 | tree, subtree = self.make_tree_files(subfile=True) | ||
| 1322 | 292 | composite = self.get_locked_composite(tree) | ||
| 1323 | 293 | self.assertEqual(set(['tree-root', 'file-id', 'subtree-id', | ||
| 1324 | 294 | 'subfile-id']), composite.all_file_ids()) | ||
| 1325 | 295 | |||
| 1326 | 296 | def test_paths2ids(self): | ||
| 1327 | 297 | tree, subtree = self.make_tree_files() | ||
| 1328 | 298 | composite = self.get_locked_composite(tree) | ||
| 1329 | 299 | self.assertEqual(set(['file-id', 'subtree-id']), | ||
| 1330 | 300 | composite.paths2ids(['file', 'subtree'])) | ||
| 1331 | 301 | |||
| 1332 | 302 | def test_iter_children(self): | ||
| 1333 | 303 | tree, subtree = self.make_tree_files(subfile=True) | ||
| 1334 | 304 | composite = self.get_locked_composite(tree) | ||
| 1335 | 305 | self.assertEqual(set(['subfile-id']), | ||
| 1336 | 306 | set(composite.iter_children('subtree-id'))) | ||
| 1337 | 307 | self.assertEqual(set(['file-id', 'subtree-id']), | ||
| 1338 | 308 | set(composite.iter_children('tree-root'))) | ||
| 1339 | 309 | |||
| 1340 | 310 | def test_case_sensitive(self): | ||
| 1341 | 311 | tree, subtree = self.make_tree_files() | ||
| 1342 | 312 | composite = self.get_locked_composite(tree) | ||
| 1343 | 313 | self.assertEqual(tree.case_sensitive, composite.case_sensitive) | ||
| 1344 | 314 | tree.case_sensitive = not tree.case_sensitive | ||
| 1345 | 315 | self.assertEqual(tree.case_sensitive, composite.case_sensitive) | ||
| 1346 | 316 | |||
| 1347 | 317 | def make_ci_tree(self): | ||
| 1348 | 318 | tree, subtree = self.make_tree_files() | ||
| 1349 | 319 | self.build_tree(['subtree/subFile']) | ||
| 1350 | 320 | subtree.add('subFile') | ||
| 1351 | 321 | return self.get_locked_composite(tree) | ||
| 1352 | 322 | |||
| 1353 | 323 | def test_get_canonical_inventory_path(self): | ||
| 1354 | 324 | """Finds subtree paths.""" | ||
| 1355 | 325 | composite = self.make_ci_tree() | ||
| 1356 | 326 | self.assertEqual('subtree/subFile', | ||
| 1357 | 327 | composite.get_canonical_inventory_path( | ||
| 1358 | 328 | 'SUBTREE/SUBFILE')) | ||
| 1359 | 329 | |||
| 1360 | 330 | def test_get_canonical_inventory_path_preserves_missing(self): | ||
| 1361 | 331 | """Returns unversion path segments verbatim.""" | ||
| 1362 | 332 | composite = self.make_ci_tree() | ||
| 1363 | 333 | self.assertEqual('subtree/subFile/X', | ||
| 1364 | 334 | composite.get_canonical_inventory_path( | ||
| 1365 | 335 | 'SUBTREE/SUBFILE/X')) | ||
| 1366 | 336 | |||
| 1367 | 337 | def test_get_canonical_inventory_paths(self): | ||
| 1368 | 338 | """Finds subtree paths.""" | ||
| 1369 | 339 | composite = self.make_ci_tree() | ||
| 1370 | 340 | self.assertEqual(['subtree/subFile'], | ||
| 1371 | 341 | composite.get_canonical_inventory_paths( | ||
| 1372 | 342 | ['SUBTREE/SUBFILE'])) | ||
| 1373 | 343 | |||
| 1374 | 344 | def test_get_file_kind(self): | ||
| 1375 | 345 | composite = self.get_locked_composite(self.make_tree_files()[0]) | ||
| 1376 | 346 | inv = composite.inventory | ||
| 1377 | 347 | self.assertEqual('file', inv.get_file_kind('file-id')) | ||
| 1378 | 348 | self.assertEqual('directory', inv.get_file_kind('subtree-id')) | ||
| 1379 | 349 | |||
| 1380 | 350 | def test_export(self): | ||
| 1381 | 351 | tree, subtree = self.make_tree_files(subfile=True) | ||
| 1382 | 352 | composite = self.get_locked_composite(tree) | ||
| 1383 | 353 | export(composite, 'output', None, None, 'subtree') | ||
| 1384 | 354 | self.assertEqual(['subfile'], os.listdir('output')) | ||
| 1385 | 355 | |||
| 1386 | 356 | def test_conflicts_path(self): | ||
| 1387 | 357 | tree, subtree = self.make_tree_files() | ||
| 1388 | 358 | subtree.add_conflicts([conflicts.ContentsConflict('foo')]) | ||
| 1389 | 359 | composite = self.get_locked_composite(tree) | ||
| 1390 | 360 | [conflict] = composite.conflicts() | ||
| 1391 | 361 | self.expectFailure('Conflict reporting for composite trees is wonky.', | ||
| 1392 | 362 | self.assertEqual, 'subtree/foo', conflict.path) | ||
| 1393 | 0 | 363 | ||
| 1394 | === modified file 'bzrlib/transform.py' | |||
| 1395 | --- bzrlib/transform.py 2009-08-28 05:00:33 +0000 | |||
| 1396 | +++ bzrlib/transform.py 2009-08-31 04:38:31 +0000 | |||
| 1397 | @@ -1315,6 +1315,7 @@ | |||
| 1398 | 1315 | tree.case_sensitive) | 1315 | tree.case_sensitive) |
| 1399 | 1316 | self._deletiondir = deletiondir | 1316 | self._deletiondir = deletiondir |
| 1400 | 1317 | 1317 | ||
| 1401 | 1318 | <<<<<<< TREE | ||
| 1402 | 1318 | def canonical_path(self, path): | 1319 | def canonical_path(self, path): |
| 1403 | 1319 | """Get the canonical tree-relative path""" | 1320 | """Get the canonical tree-relative path""" |
| 1404 | 1320 | # don't follow final symlinks | 1321 | # don't follow final symlinks |
| 1405 | @@ -1397,6 +1398,10 @@ | |||
| 1406 | 1397 | yield self.trans_id_tree_path(childpath) | 1398 | yield self.trans_id_tree_path(childpath) |
| 1407 | 1398 | 1399 | ||
| 1408 | 1399 | def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None): | 1400 | def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None): |
| 1409 | 1401 | ======= | ||
| 1410 | 1402 | def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None, | ||
| 1411 | 1403 | skip_inventory=False): | ||
| 1412 | 1404 | >>>>>>> MERGE-SOURCE | ||
| 1413 | 1400 | """Apply all changes to the inventory and filesystem. | 1405 | """Apply all changes to the inventory and filesystem. |
| 1414 | 1401 | 1406 | ||
| 1415 | 1402 | If filesystem or inventory conflicts are present, MalformedTransform | 1407 | If filesystem or inventory conflicts are present, MalformedTransform |
| 1416 | @@ -1437,7 +1442,8 @@ | |||
| 1417 | 1437 | mover.apply_deletions() | 1442 | mover.apply_deletions() |
| 1418 | 1438 | finally: | 1443 | finally: |
| 1419 | 1439 | child_pb.finished() | 1444 | child_pb.finished() |
| 1421 | 1440 | self._tree.apply_inventory_delta(inventory_delta) | 1445 | if not skip_inventory: |
| 1422 | 1446 | self._tree.apply_inventory_delta(inventory_delta) | ||
| 1423 | 1441 | self._done = True | 1447 | self._done = True |
| 1424 | 1442 | self.finalize() | 1448 | self.finalize() |
| 1425 | 1443 | return _TransformResults(modified_paths, self.rename_count) | 1449 | return _TransformResults(modified_paths, self.rename_count) |
| 1426 | 1444 | 1450 | ||
| 1427 | === modified file 'bzrlib/workingtree_4.py' | |||
| 1428 | --- bzrlib/workingtree_4.py 2009-08-25 04:43:21 +0000 | |||
| 1429 | +++ bzrlib/workingtree_4.py 2009-08-31 04:38:31 +0000 | |||
| 1430 | @@ -414,9 +414,9 @@ | |||
| 1431 | 414 | 414 | ||
| 1432 | 415 | def get_reference_revision(self, file_id, path=None): | 415 | def get_reference_revision(self, file_id, path=None): |
| 1433 | 416 | # referenced tree's revision is whatever's currently there | 416 | # referenced tree's revision is whatever's currently there |
| 1435 | 417 | return self.get_nested_tree(file_id, path).last_revision() | 417 | return self.get_nested_tree(file_id, self.branch, path).last_revision() |
| 1436 | 418 | 418 | ||
| 1438 | 419 | def get_nested_tree(self, file_id, path=None): | 419 | def get_nested_tree(self, file_id, branch, path=None): |
| 1439 | 420 | if path is None: | 420 | if path is None: |
| 1440 | 421 | path = self.id2path(file_id) | 421 | path = self.id2path(file_id) |
| 1441 | 422 | # else: check file_id is at path? | 422 | # else: check file_id is at path? |
| 1442 | @@ -1806,6 +1806,9 @@ | |||
| 1443 | 1806 | target = target.decode('utf8') | 1806 | target = target.decode('utf8') |
| 1444 | 1807 | return target | 1807 | return target |
| 1445 | 1808 | 1808 | ||
| 1446 | 1809 | def get_nested_tree(self, file_id, branch, path=None): | ||
| 1447 | 1810 | return self._get_nested_revision_tree(file_id, branch, path) | ||
| 1448 | 1811 | |||
| 1449 | 1809 | def get_revision_id(self): | 1812 | def get_revision_id(self): |
| 1450 | 1810 | """Return the revision id for this tree.""" | 1813 | """Return the revision id for this tree.""" |
| 1451 | 1811 | return self._revision_id | 1814 | return self._revision_id |
| 1452 | 1812 | 1815 | ||
| 1453 | === added file 'doc/developers/nested-trees.txt' | |||
| 1454 | --- doc/developers/nested-trees.txt 1970-01-01 00:00:00 +0000 | |||
| 1455 | +++ doc/developers/nested-trees.txt 2009-08-31 04:38:32 +0000 | |||
| 1456 | @@ -0,0 +1,28 @@ | |||
| 1457 | 1 | Nested Trees Implementation | ||
| 1458 | 2 | ########################### | ||
| 1459 | 3 | |||
| 1460 | 4 | CompositeTree | ||
| 1461 | 5 | ------------- | ||
| 1462 | 6 | CompositeTree is a shim to enable subtree support for certain commands. | ||
| 1463 | 7 | |||
| 1464 | 8 | It is constructed from a Tree (typically a RevisionTree or WorkingTree) and a | ||
| 1465 | 9 | Branch. It provides an alternate view of the Tree and its subtrees, in which | ||
| 1466 | 10 | the subtrees and their contents appear to be part of the root tree. The roots | ||
| 1467 | 11 | of subtrees are presented as directories, not as tree references. | ||
| 1468 | 12 | |||
| 1469 | 13 | It can be used with export, diff and status. It should be tested with every | ||
| 1470 | 14 | command that uses it, because it is not guaranteed to be a complete | ||
| 1471 | 15 | implementation of the Tree API. It is not suitable as input to operations that | ||
| 1472 | 16 | must know about the locations of subtrees, such as revert. | ||
| 1473 | 17 | |||
| 1474 | 18 | |||
| 1475 | 19 | NestedTrees | ||
| 1476 | 20 | ----------- | ||
| 1477 | 21 | NestedTrees is an API providing access to a set of nested trees. It is able to | ||
| 1478 | 22 | convert paths and file-ids into references to specific Trees. It provides | ||
| 1479 | 23 | caching, to avoid retrieving the same Tree multiple times. It provides | ||
| 1480 | 24 | locking, to ensure trees are locked and unlocked at appropriate times. | ||
| 1481 | 25 | |||
| 1482 | 26 | It is used by CompositeTree, and is a recommended API for all other operations. | ||
| 1483 | 27 | It is expected to acquire more capabilities as the needs of sets of nested | ||
| 1484 | 28 | trees become clearer. | ||
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
Hi Martin,
You wanted some documentation of CompositeTree to be included with the
patch that introduces it. Since NestedTrees is also introduced by this
patch and is arguably more important in the long run, I've included
documentation for it as well.
I hope this is the kind of thing you were looking for.
reviewer mbp
Aaron
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (GNU/Linux)
Comment: Using GnuPG with Mozilla - http://
iEYEARECAAYFAko
HdgAnRvPljssQet
=BAWZ
-----END PGP SIGNATURE-----