~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

• browse files at revision 6138.3.10
• compare with another revision
• download diff
• download tarball
• view history from revision 6138.3.10

• reverse the comparison (6138.3.10 to 6079)
• stop comparing with revision 6079

Show diffs side-by-side

added

removed

bzrlib/workingtree.py

54

54

    generate_ids,

55

55

    globbing,

56

56

    graph as _mod_graph,

57

 

    hashcache,

58

57

    ignores,

59

58

    inventory,

60

59

    merge,

72

71

 

73

72

from bzrlib import symbol_versioning

74

73

from bzrlib.decorators import needs_read_lock, needs_write_lock

 

74

from bzrlib.i18n import gettext

75

75

from bzrlib.lock import LogicalLockResult

76

76

import bzrlib.mutabletree

77

77

from bzrlib.mutabletree import needs_tree_write_lock

194

194

        self.basedir = realpath(basedir)

195

195

        self._control_files = _control_files

196

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

202

 

        # given path only.

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())

208

 

        hc = self._hashcache

209

 

        hc.read()

210

 

        # is this scan needed ? it makes things kinda slow.

211

 

        #hc.scan()

212

 

 

213

 

        if hc.needs_write:

214

 

            mutter("write hc")

215

 

            hc.write()

216

 

 

217

 

        self._detect_case_handling()

218

197

        self._rules_searcher = None

219

198

        self.views = self._make_views()

220

199

 

238

217

        """

239

218

        return self.bzrdir.is_control_filename(filename)

240

219

 

241

 

    def _detect_case_handling(self):

242

 

        wt_trans = self.bzrdir.get_workingtree_transport(None)

243

 

        try:

244

 

            wt_trans.stat(self._format.case_sensitive_filename)

245

 

        except errors.NoSuchFile:

246

 

            self.case_sensitive = True

247

 

        else:

248

 

            self.case_sensitive = False

249

 

 

250

 

        self._setup_directory_is_tree_reference()

251

 

 

252

220

    branch = property(

253

221

        fget=lambda self: self._branch,

254

222

        doc="""The branch this WorkingTree is connected to.

257

225

            the working tree has been constructed from.

258

226

            """)

259

227

 

 

228

    def has_versioned_directories(self):

 

229

        """See `Tree.has_versioned_directories`."""

 

230

        return self._format.supports_versioned_directories

 

231

 

260

232

    def break_lock(self):

261

233

        """Break a lock if one is present from another instance.

262

234

 

331

303

                if view_files:

332

304

                    file_list = view_files

333

305

                    view_str = views.view_display_str(view_files)

334

 

                    note("Ignoring files outside view. View is %s" % view_str)

 

306

                    note(gettext("Ignoring files outside view. View is %s") % view_str)

335

307

            return tree, file_list

336

308

        if default_directory == u'.':

337

309

            seed = file_list[0]

1062

1034

            stream.write(bytes)

1063

1035

        finally:

1064

1036

            stream.close()

1065

 

        # TODO: update the hashcache here ?

1066

1037

 

1067

1038

    def extras(self):

1068

1039

        """Yield all unversioned files in this WorkingTree.

1528

1499

                                             show_base=show_base)

1529

1500

            if nb_conflicts:

1530

1501

                self.add_parent_tree((old_tip, other_tree))

1531

 

                note('Rerun update after fixing the conflicts.')

 

1502

                note(gettext('Rerun update after fixing the conflicts.'))

1532

1503

                return nb_conflicts

1533

1504

 

1534

1505

        if last_rev != _mod_revision.ensure_null(revision):

1576

1547

            last_rev = parent_trees[0][0]

1577

1548

        return nb_conflicts

1578

1549

 

1579

 

    def _write_hashcache_if_dirty(self):

1580

 

        """Write out the hashcache if it is dirty."""

1581

 

        if self._hashcache.needs_write:

1582

 

            try:

1583

 

                self._hashcache.write()

1584

 

            except OSError, e:

1585

 

                if e.errno not in (errno.EPERM, errno.EACCES):

1586

 

                    raise

1587

 

                # TODO: jam 20061219 Should this be a warning? A single line

1588

 

                #       warning might be sufficient to let the user know what

1589

 

                #       is going on.

1590

 

                mutter('Could not write hashcache for %s\nError: %s',

1591

 

                              self._hashcache.cache_file_name(), e)

1592

 

 

1593

1550

    def set_conflicts(self, arg):

1594

1551

        raise errors.UnsupportedOperation(self.set_conflicts, self)

1595

1552

 

1827

1784

            branch=branch, _control_files=_control_files, _internal=_internal,

1828

1785

            _format=_format, _bzrdir=_bzrdir)

1829

1786

 

 

1787

        self._detect_case_handling()

 

1788

 

1830

1789

        if _inventory is None:

1831

1790

            # This will be acquired on lock_read() or lock_write()

1832

1791

            self._inventory_is_modified = False

1851

1810

        self._inventory = inv

1852

1811

        self._inventory_is_modified = dirty

1853

1812

 

 

1813

    def _detect_case_handling(self):

 

1814

        wt_trans = self.bzrdir.get_workingtree_transport(None)

 

1815

        try:

 

1816

            wt_trans.stat(self._format.case_sensitive_filename)

 

1817

        except errors.NoSuchFile:

 

1818

            self.case_sensitive = True

 

1819

        else:

 

1820

            self.case_sensitive = False

 

1821

 

 

1822

        self._setup_directory_is_tree_reference()

 

1823

 

1854

1824

    def _serialize(self, inventory, out_file):

1855

1825

        xml5.serializer_v5.write_inventory(self._inventory, out_file,

1856

1826

            working=True)

2160

2130

            mode=self.bzrdir._get_file_mode())

2161

2131

        self._inventory_is_modified = False

2162

2132

 

2163

 

    @needs_read_lock

2164

 

    def get_file_sha1(self, file_id, path=None, stat_value=None):

2165

 

        if not path:

2166

 

            path = self._inventory.id2path(file_id)

2167

 

        return self._hashcache.get_sha1(path, stat_value)

2168

 

 

2169

2133

    def get_file_mtime(self, file_id, path=None):

2170

2134

        """See Tree.get_file_mtime."""

2171

2135

        if not path:

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1