193
199
self._branch = self.bzrdir.open_branch()
194
200
self.basedir = realpath(basedir)
195
self._control_files = _control_files
196
self._transport = self._control_files._transport
197
# update the whole cache up front and write to disk if anything changed;
198
# in the future we might want to do this more selectively
199
# two possible ways offer themselves : in self._unlock, write the cache
200
# if needed, or, when the cache sees a change, append it to the hash
201
# cache file, and have the parser take the most recent entry for a
203
wt_trans = self.bzrdir.get_workingtree_transport(None)
204
cache_filename = wt_trans.local_abspath('stat-cache')
205
self._hashcache = hashcache.HashCache(basedir, cache_filename,
206
self.bzrdir._get_file_mode(),
207
self._content_filter_stack_provider())
210
# is this scan needed ? it makes things kinda slow.
217
self._detect_case_handling()
201
self._transport = _transport
218
202
self._rules_searcher = None
219
203
self.views = self._make_views()
1188
1169
:return: A bzrlib.lock.LogicalLockResult.
1190
if not self.is_locked():
1192
self.branch.lock_read()
1194
self._control_files.lock_read()
1195
return LogicalLockResult(self.unlock)
1197
self.branch.unlock()
1171
raise NotImplementedError(self.lock_read)
1200
1173
def lock_tree_write(self):
1201
1174
"""See MutableTree.lock_tree_write, and WorkingTree.unlock.
1203
1176
:return: A bzrlib.lock.LogicalLockResult.
1205
if not self.is_locked():
1207
self.branch.lock_read()
1209
self._control_files.lock_write()
1210
return LogicalLockResult(self.unlock)
1212
self.branch.unlock()
1178
raise NotImplementedError(self.lock_tree_write)
1215
1180
def lock_write(self):
1216
1181
"""See MutableTree.lock_write, and WorkingTree.unlock.
1218
1183
:return: A bzrlib.lock.LogicalLockResult.
1220
if not self.is_locked():
1222
self.branch.lock_write()
1224
self._control_files.lock_write()
1225
return LogicalLockResult(self.unlock)
1227
self.branch.unlock()
1185
raise NotImplementedError(self.lock_write)
1230
1187
def get_physical_lock_status(self):
1231
return self._control_files.get_physical_lock_status()
1233
def _reset_data(self):
1234
"""Reset transient data that cannot be revalidated."""
1235
raise NotImplementedError(self._reset_data)
1188
raise NotImplementedError(self.get_physical_lock_status)
1237
1190
def set_last_revision(self, new_revision):
1238
1191
"""Change the last revision in the working tree."""
1404
1357
basis_tree.unlock()
1405
1358
return conflicts
1361
def store_uncommitted(self):
1362
"""Store uncommitted changes from the tree in the branch."""
1363
target_tree = self.basis_tree()
1364
shelf_creator = shelf.ShelfCreator(self, target_tree)
1366
if not shelf_creator.shelve_all():
1368
self.branch.store_uncommitted(shelf_creator)
1369
shelf_creator.transform()
1371
shelf_creator.finalize()
1372
note('Uncommitted changes stored in branch "%s".', self.branch.nick)
1375
def restore_uncommitted(self):
1376
"""Restore uncommitted changes from the branch into the tree."""
1377
unshelver = self.branch.get_unshelver(self)
1378
if unshelver is None:
1381
merger = unshelver.make_merger()
1382
merger.ignore_zero = True
1384
self.branch.store_uncommitted(None)
1386
unshelver.finalize()
1407
1388
def revision_tree(self, revision_id):
1408
1389
"""See Tree.revision_tree.
1862
1843
def _deserialize(selt, in_file):
1863
1844
return xml5.serializer_v5.read_inventory(in_file)
1846
def break_lock(self):
1847
"""Break a lock if one is present from another instance.
1849
Uses the ui factory to ask for confirmation if the lock may be from
1852
This will probe the repository for its lock as well.
1854
self._control_files.break_lock()
1855
self.branch.break_lock()
1857
def is_locked(self):
1858
return self._control_files.is_locked()
1860
def _must_be_locked(self):
1861
if not self.is_locked():
1862
raise errors.ObjectNotLocked(self)
1864
def lock_read(self):
1865
"""Lock the tree for reading.
1867
This also locks the branch, and can be unlocked via self.unlock().
1869
:return: A bzrlib.lock.LogicalLockResult.
1871
if not self.is_locked():
1873
self.branch.lock_read()
1875
self._control_files.lock_read()
1876
return LogicalLockResult(self.unlock)
1878
self.branch.unlock()
1881
def lock_tree_write(self):
1882
"""See MutableTree.lock_tree_write, and WorkingTree.unlock.
1884
:return: A bzrlib.lock.LogicalLockResult.
1886
if not self.is_locked():
1888
self.branch.lock_read()
1890
self._control_files.lock_write()
1891
return LogicalLockResult(self.unlock)
1893
self.branch.unlock()
1896
def lock_write(self):
1897
"""See MutableTree.lock_write, and WorkingTree.unlock.
1899
:return: A bzrlib.lock.LogicalLockResult.
1901
if not self.is_locked():
1903
self.branch.lock_write()
1905
self._control_files.lock_write()
1906
return LogicalLockResult(self.unlock)
1908
self.branch.unlock()
1911
def get_physical_lock_status(self):
1912
return self._control_files.get_physical_lock_status()
1865
1914
@needs_tree_write_lock
1866
1915
def _write_inventory(self, inv):
1867
1916
"""Write inventory as the current inventory."""
2067
2112
def has_id(self, file_id):
2068
2113
# files that have been deleted are excluded
2069
inv = self.inventory
2070
if not inv.has_id(file_id):
2114
inv, inv_file_id = self._unpack_file_id(file_id)
2115
if not inv.has_id(inv_file_id):
2072
path = inv.id2path(file_id)
2117
path = inv.id2path(inv_file_id)
2073
2118
return osutils.lexists(self.abspath(path))
2075
2120
def has_or_had_id(self, file_id):
2076
if file_id == self.inventory.root.file_id:
2121
if file_id == self.get_root_id():
2078
return self.inventory.has_id(file_id)
2123
inv, inv_file_id = self._unpack_file_id(file_id)
2124
return inv.has_id(inv_file_id)
2080
@symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2126
def all_file_ids(self):
2082
2127
"""Iterate through file_ids for this tree.
2084
2129
file_ids are in a WorkingTree if they are in the working inventory
2085
2130
and the working file exists.
2087
inv = self._inventory
2088
for path, ie in inv.iter_entries():
2089
if osutils.lexists(self.abspath(path)):
2133
for path, ie in self.iter_entries_by_dir():
2092
2137
@needs_tree_write_lock
2093
2138
def set_last_revision(self, new_revision):
2164
2209
mode=self.bzrdir._get_file_mode())
2165
2210
self._inventory_is_modified = False
2168
def get_file_sha1(self, file_id, path=None, stat_value=None):
2170
path = self._inventory.id2path(file_id)
2171
return self._hashcache.get_sha1(path, stat_value)
2173
2212
def get_file_mtime(self, file_id, path=None):
2174
2213
"""See Tree.get_file_mtime."""
2176
path = self.inventory.id2path(file_id)
2177
return os.lstat(self.abspath(path)).st_mtime
2215
path = self.id2path(file_id)
2217
return os.lstat(self.abspath(path)).st_mtime
2219
if e.errno == errno.ENOENT:
2220
raise errors.FileTimestampUnavailable(path)
2179
2223
def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
2180
file_id = self.path2id(path)
2224
inv, file_id = self._path2inv_file_id(path)
2181
2225
if file_id is None:
2182
2226
# For unversioned files on win32, we just assume they are not
2185
return self._inventory[file_id].executable
2229
return inv[file_id].executable
2187
2231
def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
2188
2232
mode = stat_result.st_mode
2189
2233
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2191
if not supports_executable():
2192
def is_executable(self, file_id, path=None):
2193
return self._inventory[file_id].executable
2195
_is_executable_from_path_and_stat = \
2196
_is_executable_from_path_and_stat_from_basis
2198
def is_executable(self, file_id, path=None):
2235
def is_executable(self, file_id, path=None):
2236
if not self._supports_executable():
2237
inv, inv_file_id = self._unpack_file_id(file_id)
2238
return inv[inv_file_id].executable
2200
2241
path = self.id2path(file_id)
2201
2242
mode = os.lstat(self.abspath(path)).st_mode
2202
2243
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2204
_is_executable_from_path_and_stat = \
2205
_is_executable_from_path_and_stat_from_stat
2245
def _is_executable_from_path_and_stat(self, path, stat_result):
2246
if not self._supports_executable():
2247
return self._is_executable_from_path_and_stat_from_basis(path, stat_result)
2249
return self._is_executable_from_path_and_stat_from_stat(path, stat_result)
2207
2251
@needs_tree_write_lock
2208
2252
def _add(self, files, ids, kinds):
2287
2334
for key, line in annotator.annotate_flat(this_key)]
2288
2335
return annotations
2337
def _put_rio(self, filename, stanzas, header):
2338
self._must_be_locked()
2339
my_file = _mod_rio.rio_file(stanzas, header)
2340
self._transport.put_file(filename, my_file,
2341
mode=self.bzrdir._get_file_mode())
2343
@needs_tree_write_lock
2344
def set_merge_modified(self, modified_hashes):
2346
for file_id, hash in modified_hashes.iteritems():
2347
yield _mod_rio.Stanza(file_id=file_id.decode('utf8'),
2349
self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
2290
2351
@needs_read_lock
2291
2352
def merge_modified(self):
2292
2353
"""Return a dictionary of files modified by a merge.
2348
2409
other_tree.lock_tree_write()
2350
2411
new_parents = other_tree.get_parent_ids()
2351
other_root = other_tree.inventory.root
2412
other_root = other_tree.root_inventory.root
2352
2413
other_root.parent_id = new_root_parent
2353
2414
other_root.name = osutils.basename(other_tree_path)
2354
self.inventory.add(other_root)
2355
add_children(self.inventory, other_root)
2356
self._write_inventory(self.inventory)
2415
self.root_inventory.add(other_root)
2416
add_children(self.root_inventory, other_root)
2417
self._write_inventory(self.root_inventory)
2357
2418
# normally we don't want to fetch whole repositories, but i think
2358
2419
# here we really do want to consolidate the whole thing.
2359
2420
for parent_id in other_tree.get_parent_ids():
2675
2737
raise errors.BzrRenameFailedError(from_rel,to_rel,
2676
2738
errors.NotVersionedError(path=from_rel))
2677
2739
# put entry back in the inventory so we can rename it
2678
from_entry = basis_tree.inventory[from_id].copy()
2740
from_entry = basis_tree.root_inventory[from_id].copy()
2741
from_inv.add(from_entry)
2681
from_entry = inv[from_id]
2743
from_inv, from_inv_id = self._unpack_file_id(from_id)
2744
from_entry = from_inv[from_inv_id]
2682
2745
from_parent_id = from_entry.parent_id
2683
2746
to_dir, to_tail = os.path.split(to_rel)
2684
to_dir_id = inv.path2id(to_dir)
2747
to_inv, to_dir_id = self._path2inv_file_id(to_dir)
2685
2748
rename_entry = InventoryWorkingTree._RenameEntry(from_rel=from_rel,
2686
2749
from_id=from_id,
2687
2750
from_tail=from_tail,
3017
3090
supports_versioned_directories = None
3020
def find_format_string(klass, a_bzrdir):
3021
"""Return format name for the working tree object in a_bzrdir."""
3023
transport = a_bzrdir.get_workingtree_transport(None)
3024
return transport.get_bytes("format")
3025
except errors.NoSuchFile:
3026
raise errors.NoWorkingTree(base=transport.base)
3029
def find_format(klass, a_bzrdir):
3030
"""Return the format for the working tree object in a_bzrdir."""
3032
format_string = klass.find_format_string(a_bzrdir)
3033
format_string = bzrdir.extract_format_string(format_string)
3034
return format_registry.get(format_string)
3036
raise errors.UnknownFormatError(format=format_string,
3037
kind="working tree")
3039
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
3092
def initialize(self, controldir, revision_id=None, from_branch=None,
3040
3093
accelerator_tree=None, hardlink=False):
3041
"""Initialize a new working tree in a_bzrdir.
3094
"""Initialize a new working tree in controldir.
3043
:param a_bzrdir: BzrDir to initialize the working tree in.
3096
:param controldir: ControlDir to initialize the working tree in.
3044
3097
:param revision_id: allows creating a working tree at a different
3045
3098
revision than the branch is at.
3046
3099
:param from_branch: Branch to checkout
3091
3133
"""True if this format supports stored views."""
3095
@symbol_versioning.deprecated_method(
3096
symbol_versioning.deprecated_in((2, 4, 0)))
3097
def register_format(klass, format):
3098
format_registry.register(format)
3101
@symbol_versioning.deprecated_method(
3102
symbol_versioning.deprecated_in((2, 4, 0)))
3103
def register_extra_format(klass, format):
3104
format_registry.register_extra(format)
3107
@symbol_versioning.deprecated_method(
3108
symbol_versioning.deprecated_in((2, 4, 0)))
3109
def unregister_extra_format(klass, format):
3110
format_registry.unregister_extra(format)
3113
@symbol_versioning.deprecated_method(
3114
symbol_versioning.deprecated_in((2, 4, 0)))
3115
def get_formats(klass):
3116
return format_registry._get_all()
3119
@symbol_versioning.deprecated_method(
3120
symbol_versioning.deprecated_in((2, 4, 0)))
3121
def set_default_format(klass, format):
3122
format_registry.set_default(format)
3125
@symbol_versioning.deprecated_method(
3126
symbol_versioning.deprecated_in((2, 4, 0)))
3127
def unregister_format(klass, format):
3128
format_registry.remove(format)
3136
def get_controldir_for_branch(self):
3137
"""Get the control directory format for creating branches.
3139
This is to support testing of working tree formats that can not exist
3140
in the same control directory as a branch.
3142
return self._matchingbzrdir
3145
class WorkingTreeFormatMetaDir(bzrdir.BzrFormat, WorkingTreeFormat):
3146
"""Base class for working trees that live in bzr meta directories."""
3149
WorkingTreeFormat.__init__(self)
3150
bzrdir.BzrFormat.__init__(self)
3153
def find_format_string(klass, controldir):
3154
"""Return format name for the working tree object in controldir."""
3156
transport = controldir.get_workingtree_transport(None)
3157
return transport.get_bytes("format")
3158
except errors.NoSuchFile:
3159
raise errors.NoWorkingTree(base=transport.base)
3162
def find_format(klass, controldir):
3163
"""Return the format for the working tree object in controldir."""
3164
format_string = klass.find_format_string(controldir)
3165
return klass._find_format(format_registry, 'working tree',
3168
def check_support_status(self, allow_unsupported, recommend_upgrade=True,
3170
WorkingTreeFormat.check_support_status(self,
3171
allow_unsupported=allow_unsupported, recommend_upgrade=recommend_upgrade,
3173
bzrdir.BzrFormat.check_support_status(self, allow_unsupported=allow_unsupported,
3174
recommend_upgrade=recommend_upgrade, basedir=basedir)
3176
def get_controldir_for_branch(self):
3177
"""Get the control directory format for creating branches.
3179
This is to support testing of working tree formats that can not exist
3180
in the same control directory as a branch.
3182
return self._matchingbzrdir
3185
class WorkingTreeFormatMetaDir(bzrdir.BzrFormat, WorkingTreeFormat):
3186
"""Base class for working trees that live in bzr meta directories."""
3189
WorkingTreeFormat.__init__(self)
3190
bzrdir.BzrFormat.__init__(self)
3193
def find_format_string(klass, controldir):
3194
"""Return format name for the working tree object in controldir."""
3196
transport = controldir.get_workingtree_transport(None)
3197
return transport.get_bytes("format")
3198
except errors.NoSuchFile:
3199
raise errors.NoWorkingTree(base=transport.base)
3202
def find_format(klass, controldir):
3203
"""Return the format for the working tree object in controldir."""
3204
format_string = klass.find_format_string(controldir)
3205
return klass._find_format(format_registry, 'working tree',
3208
def check_support_status(self, allow_unsupported, recommend_upgrade=True,
3210
WorkingTreeFormat.check_support_status(self,
3211
allow_unsupported=allow_unsupported, recommend_upgrade=recommend_upgrade,
3213
bzrdir.BzrFormat.check_support_status(self, allow_unsupported=allow_unsupported,
3214
recommend_upgrade=recommend_upgrade, basedir=basedir)
3131
3217
format_registry.register_lazy("Bazaar Working Tree Format 4 (bzr 0.15)\n",