/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

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

• reverse the comparison (5200.3.2 to 5372)
• stop comparing with revision 5372

Show diffs side-by-side

added

removed

bzrlib/workingtree.py

61

61

    revisiontree,

62

62

    trace,

63

63

    transform,

64

 

    transport,

65

64

    ui,

66

65

    views,

67

66

    xml5,

68

67

    xml7,

69

68

    )

 

69

import bzrlib.branch

 

70

from bzrlib.transport import get_transport

70

71

from bzrlib.workingtree_4 import (

71

72

    WorkingTreeFormat4,

72

73

    WorkingTreeFormat5,

76

77

 

77

78

from bzrlib import symbol_versioning

78

79

from bzrlib.decorators import needs_read_lock, needs_write_lock

79

 

from bzrlib.lock import LogicalLockResult

80

80

from bzrlib.lockable_files import LockableFiles

81

81

from bzrlib.lockdir import LockDir

82

82

import bzrlib.mutabletree

176

176

 

177

177

    It is possible for a `WorkingTree` to have a filename which is

178

178

    not listed in the Inventory and vice versa.

179

 

 

180

 

    :ivar basedir: The root of the tree on disk. This is a unicode path object

181

 

        (as opposed to a URL).

182

179

    """

183

180

 

184

181

    # override this to set the strategy for storing views

349

346

        if path is None:

350

347

            path = osutils.getcwd()

351

348

        control, relpath = bzrdir.BzrDir.open_containing(path)

 

349

 

352

350

        return control.open_workingtree(), relpath

353

351

 

354

352

    @staticmethod

355

 

    def open_containing_paths(file_list, default_directory='.',

356

 

        canonicalize=True, apply_view=True):

357

 

        """Open the WorkingTree that contains a set of paths.

358

 

 

359

 

        Fail if the paths given are not all in a single tree.

360

 

 

361

 

        This is used for the many command-line interfaces that take a list of

362

 

        any number of files and that require they all be in the same tree.

363

 

        """

364

 

        # recommended replacement for builtins.internal_tree_files

365

 

        if file_list is None or len(file_list) == 0:

366

 

            tree = WorkingTree.open_containing(default_directory)[0]

367

 

            # XXX: doesn't really belong here, and seems to have the strange

368

 

            # side effect of making it return a bunch of files, not the whole

369

 

            # tree -- mbp 20100716

370

 

            if tree.supports_views() and apply_view:

371

 

                view_files = tree.views.lookup_view()

372

 

                if view_files:

373

 

                    file_list = view_files

374

 

                    view_str = views.view_display_str(view_files)

375

 

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

376

 

            return tree, file_list

377

 

        tree = WorkingTree.open_containing(file_list[0])[0]

378

 

        return tree, tree.safe_relpath_files(file_list, canonicalize,

379

 

            apply_view=apply_view)

380

 

 

381

 

    def safe_relpath_files(self, file_list, canonicalize=True, apply_view=True):

382

 

        """Convert file_list into a list of relpaths in tree.

383

 

 

384

 

        :param self: A tree to operate on.

385

 

        :param file_list: A list of user provided paths or None.

386

 

        :param apply_view: if True and a view is set, apply it or check that

387

 

            specified files are within it

388

 

        :return: A list of relative paths.

389

 

        :raises errors.PathNotChild: When a provided path is in a different self

390

 

            than self.

391

 

        """

392

 

        if file_list is None:

393

 

            return None

394

 

        if self.supports_views() and apply_view:

395

 

            view_files = self.views.lookup_view()

396

 

        else:

397

 

            view_files = []

398

 

        new_list = []

399

 

        # self.relpath exists as a "thunk" to osutils, but canonical_relpath

400

 

        # doesn't - fix that up here before we enter the loop.

401

 

        if canonicalize:

402

 

            fixer = lambda p: osutils.canonical_relpath(self.basedir, p)

403

 

        else:

404

 

            fixer = self.relpath

405

 

        for filename in file_list:

406

 

            relpath = fixer(osutils.dereference_path(filename))

407

 

            if view_files and not osutils.is_inside_any(view_files, relpath):

408

 

                raise errors.FileOutsideView(filename, view_files)

409

 

            new_list.append(relpath)

410

 

        return new_list

411

 

 

412

 

    @staticmethod

413

353

    def open_downlevel(path=None):

414

354

        """Open an unsupported working tree.

415

355

 

428

368

                return True, None

429

369

            else:

430

370

                return True, tree

431

 

        t = transport.get_transport(location)

432

 

        iterator = bzrdir.BzrDir.find_bzrdirs(t, evaluate=evaluate,

 

371

        transport = get_transport(location)

 

372

        iterator = bzrdir.BzrDir.find_bzrdirs(transport, evaluate=evaluate,

433

373

                                              list_current=list_current)

434

 

        return [tr for tr in iterator if tr is not None]

 

374

        return [t for t in iterator if t is not None]

435

375

 

436

376

    # should be deprecated - this is slow and in any case treating them as a

437

377

    # container is (we now know) bad style -- mbp 20070302

522

462

        return (file_obj, stat_value)

523

463

 

524

464

    def get_file_text(self, file_id, path=None, filtered=True):

525

 

        my_file = self.get_file(file_id, path=path, filtered=filtered)

526

 

        try:

527

 

            return my_file.read()

528

 

        finally:

529

 

            my_file.close()

 

465

        return self.get_file(file_id, path=path, filtered=filtered).read()

530

466

 

531

467

    def get_file_byname(self, filename, filtered=True):

532

468

        path = self.abspath(filename)

586

522

 

587

523

        # Now we have the parents of this content

588

524

        annotator = self.branch.repository.texts.get_annotator()

589

 

        text = self.get_file_text(file_id)

 

525

        text = self.get_file(file_id).read()

590

526

        this_key =(file_id, default_revision)

591

527

        annotator.add_special_text(this_key, file_parent_keys, text)

592

528

        annotations = [(key[-1], line)

1321

1257

                stack.pop()

1322

1258

 

1323

1259

    @needs_tree_write_lock

1324

 

    def move(self, from_paths, to_dir=None, after=False):

 

1260

    def move(self, from_paths, to_dir=None, after=False, **kwargs):

1325

1261

        """Rename files.

1326

1262

 

1327

1263

        to_dir must exist in the inventory.

1361

1297

 

1362

1298

        # check for deprecated use of signature

1363

1299

        if to_dir is None:

1364

 

            raise TypeError('You must supply a target directory')

 

1300

            to_dir = kwargs.get('to_name', None)

 

1301

            if to_dir is None:

 

1302

                raise TypeError('You must supply a target directory')

 

1303

            else:

 

1304

                symbol_versioning.warn('The parameter to_name was deprecated'

 

1305

                                       ' in version 0.13. Use to_dir instead',

 

1306

                                       DeprecationWarning)

 

1307

 

1365

1308

        # check destination directory

1366

1309

        if isinstance(from_paths, basestring):

1367

1310

            raise ValueError()

1855

1798

            raise errors.ObjectNotLocked(self)

1856

1799

 

1857

1800

    def lock_read(self):

1858

 

        """Lock the tree for reading.

1859

 

 

1860

 

        This also locks the branch, and can be unlocked via self.unlock().

1861

 

 

1862

 

        :return: A bzrlib.lock.LogicalLockResult.

1863

 

        """

 

1801

        """See Branch.lock_read, and WorkingTree.unlock."""

1864

1802

        if not self.is_locked():

1865

1803

            self._reset_data()

1866

1804

        self.branch.lock_read()

1867

1805

        try:

1868

 

            self._control_files.lock_read()

1869

 

            return LogicalLockResult(self.unlock)

 

1806

            return self._control_files.lock_read()

1870

1807

        except:

1871

1808

            self.branch.unlock()

1872

1809

            raise

1873

1810

 

1874

1811

    def lock_tree_write(self):

1875

 

        """See MutableTree.lock_tree_write, and WorkingTree.unlock.

1876

 

 

1877

 

        :return: A bzrlib.lock.LogicalLockResult.

1878

 

        """

 

1812

        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""

1879

1813

        if not self.is_locked():

1880

1814

            self._reset_data()

1881

1815

        self.branch.lock_read()

1882

1816

        try:

1883

 

            self._control_files.lock_write()

1884

 

            return LogicalLockResult(self.unlock)

 

1817

            return self._control_files.lock_write()

1885

1818

        except:

1886

1819

            self.branch.unlock()

1887

1820

            raise

1888

1821

 

1889

1822

    def lock_write(self):

1890

 

        """See MutableTree.lock_write, and WorkingTree.unlock.

1891

 

 

1892

 

        :return: A bzrlib.lock.LogicalLockResult.

1893

 

        """

 

1823

        """See MutableTree.lock_write, and WorkingTree.unlock."""

1894

1824

        if not self.is_locked():

1895

1825

            self._reset_data()

1896

1826

        self.branch.lock_write()

1897

1827

        try:

1898

 

            self._control_files.lock_write()

1899

 

            return LogicalLockResult(self.unlock)

 

1828

            return self._control_files.lock_write()

1900

1829

        except:

1901

1830

            self.branch.unlock()

1902

1831

            raise

2027

1956

        def recurse_directory_to_add_files(directory):

2028

1957

            # Recurse directory and add all files

2029

1958

            # so we can check if they have changed.

2030

 

            for parent_info, file_infos in self.walkdirs(directory):

 

1959

            for parent_info, file_infos in\

 

1960

                self.walkdirs(directory):

2031

1961

                for relpath, basename, kind, lstat, fileid, kind in file_infos:

2032

1962

                    # Is it versioned or ignored?

2033

1963

                    if self.path2id(relpath) or self.is_ignored(relpath):

2068

1998

                            # ... but not ignored

2069

1999

                            has_changed_files = True

2070

2000

                            break

2071

 

                    elif (content_change and (kind[1] is not None) and

2072

 

                            osutils.is_inside_any(files, path[1])):

2073

 

                        # Versioned and changed, but not deleted, and still

2074

 

                        # in one of the dirs to be deleted.

 

2001

                    elif content_change and (kind[1] is not None):

 

2002

                        # Versioned and changed, but not deleted

2075

2003

                        has_changed_files = True

2076

2004

                        break

2077

2005

 

2708

2636

 

2709

2637

        In Format2 WorkingTrees we have a single lock for the branch and tree

2710

2638

        so lock_tree_write() degrades to lock_write().

2711

 

 

2712

 

        :return: An object with an unlock method which will release the lock

2713

 

            obtained.

2714

2639

        """

2715

2640

        self.branch.lock_write()

2716

2641

        try:

2717

 

            self._control_files.lock_write()

2718

 

            return self

 

2642

            return self._control_files.lock_write()

2719

2643

        except:

2720

2644

            self.branch.unlock()

2721

2645

            raise

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0