~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

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

Show diffs side-by-side

added

removed

bzrlib/inventory.py

1

 

# (C) 2005 Canonical Ltd

 

1

# Copyright (C) 2005, 2006 Canonical Ltd

2

2

#

3

3

# This program is free software; you can redistribute it and/or modify

4

4

# it under the terms of the GNU General Public License as published by

37

37

import bzrlib

38

38

from bzrlib.osutils import (pumpfile, quotefn, splitpath, joinpath,

39

39

                            pathjoin, sha_strings)

 

40

from bzrlib.errors import (NotVersionedError, InvalidEntryName,

 

41

                           BzrError, BzrCheckError, BinaryFile)

40

42

from bzrlib.trace import mutter

41

 

from bzrlib.errors import (NotVersionedError, InvalidEntryName,

42

 

                           BzrError, BzrCheckError)

43

43

 

44

44

 

45

45

class InventoryEntry(object):

119

119

                 'revision']

120

120

 

121

121

    def _add_text_to_weave(self, new_lines, parents, weave_store, transaction):

122

 

        versionedfile = weave_store.get_weave(self.file_id, transaction)

 

122

        versionedfile = weave_store.get_weave_or_empty(self.file_id,

 

123

                                                       transaction)

123

124

        versionedfile.add_lines(self.revision, parents, new_lines)

 

125

        versionedfile.clear_cache()

124

126

 

125

127

    def detect_changes(self, old_entry):

126

128

        """Return a (text_modified, meta_modified) from this to old_entry.

151

153

             output_to, reverse=False):

152

154

        """Perform a diff between two entries of the same kind."""

153

155

 

154

 

    def find_previous_heads(self, previous_inventories, entry_weave):

 

156

    def find_previous_heads(self, previous_inventories,

 

157

                            versioned_file_store,

 

158

                            transaction,

 

159

                            entry_vf=None):

155

160

        """Return the revisions and entries that directly preceed this.

156

161

 

157

162

        Returned as a map from revision to inventory entry.

159

164

        This is a map containing the file revisions in all parents

160

165

        for which the file exists, and its revision is not a parent of

161

166

        any other. If the file is new, the set will be empty.

 

167

 

 

168

        :param versioned_file_store: A store where ancestry data on this

 

169

                                     file id can be queried.

 

170

        :param transaction: The transaction that queries to the versioned 

 

171

                            file store should be completed under.

 

172

        :param entry_vf: The entry versioned file, if its already available.

162

173

        """

163

174

        def get_ancestors(weave, entry):

164

175

            return set(weave.get_ancestry(entry.revision))

 

176

        # revision:ie mapping for each ie found in previous_inventories.

 

177

        candidates = {}

 

178

        # revision:ie mapping with one revision for each head.

165

179

        heads = {}

 

180

        # revision: ancestor list for each head

166

181

        head_ancestors = {}

 

182

        # identify candidate head revision ids.

167

183

        for inv in previous_inventories:

168

184

            if self.file_id in inv:

169

185

                ie = inv[self.file_id]

170

186

                assert ie.file_id == self.file_id

171

 

                if ie.revision in heads:

172

 

                    # fixup logic, there was a bug in revision updates.

173

 

                    # with x bit support.

 

187

                if ie.revision in candidates:

 

188

                    # same revision value in two different inventories:

 

189

                    # correct possible inconsistencies:

 

190

                    #     * there was a bug in revision updates with 'x' bit 

 

191

                    #       support.

174

192

                    try:

175

 

                        if heads[ie.revision].executable != ie.executable:

176

 

                            heads[ie.revision].executable = False

 

193

                        if candidates[ie.revision].executable != ie.executable:

 

194

                            candidates[ie.revision].executable = False

177

195

                            ie.executable = False

178

196

                    except AttributeError:

179

197

                        pass

180

 

                    assert heads[ie.revision] == ie

 

198

                    # must now be the same.

 

199

                    assert candidates[ie.revision] == ie

181

200

                else:

182

 

                    # may want to add it.

183

 

                    # may already be covered:

184

 

                    already_present = 0 != len(

185

 

                        [head for head in heads 

186

 

                         if ie.revision in head_ancestors[head]])

187

 

                    if already_present:

188

 

                        # an ancestor of a known head.

189

 

                        continue

190

 

                    # definately a head:

191

 

                    ancestors = get_ancestors(entry_weave, ie)

192

 

                    # may knock something else out:

193

 

                    check_heads = list(heads.keys())

194

 

                    for head in check_heads:

195

 

                        if head in ancestors:

196

 

                            # this head is not really a head

197

 

                            heads.pop(head)

198

 

                    head_ancestors[ie.revision] = ancestors

199

 

                    heads[ie.revision] = ie

 

201

                    # add this revision as a candidate.

 

202

                    candidates[ie.revision] = ie

 

203

 

 

204

        # common case optimisation

 

205

        if len(candidates) == 1:

 

206

            # if there is only one candidate revision found

 

207

            # then we can opening the versioned file to access ancestry:

 

208

            # there cannot be any ancestors to eliminate when there is 

 

209

            # only one revision available.

 

210

            heads[ie.revision] = ie

 

211

            return heads

 

212

 

 

213

        # eliminate ancestors amongst the available candidates:

 

214

        # heads are those that are not an ancestor of any other candidate

 

215

        # - this provides convergence at a per-file level.

 

216

        for ie in candidates.values():

 

217

            # may be an ancestor of a known head:

 

218

            already_present = 0 != len(

 

219

                [head for head in heads 

 

220

                 if ie.revision in head_ancestors[head]])

 

221

            if already_present:

 

222

                # an ancestor of an analyzed candidate.

 

223

                continue

 

224

            # not an ancestor of a known head:

 

225

            # load the versioned file for this file id if needed

 

226

            if entry_vf is None:

 

227

                entry_vf = versioned_file_store.get_weave_or_empty(

 

228

                    self.file_id, transaction)

 

229

            ancestors = get_ancestors(entry_vf, ie)

 

230

            # may knock something else out:

 

231

            check_heads = list(heads.keys())

 

232

            for head in check_heads:

 

233

                if head in ancestors:

 

234

                    # this previously discovered 'head' is not

 

235

                    # really a head - its an ancestor of the newly 

 

236

                    # found head,

 

237

                    heads.pop(head)

 

238

            head_ancestors[ie.revision] = ancestors

 

239

            heads[ie.revision] = ie

200

240

        return heads

201

241

 

202

242

    def get_tar_item(self, root, dp, now, tree):

289

329

 

290

330

        This is a template method, override _check for kind specific

291

331

        tests.

 

332

 

 

333

        :param checker: Check object providing context for the checks; 

 

334

             can be used to find out what parts of the repository have already

 

335

             been checked.

 

336

        :param rev_id: Revision id from which this InventoryEntry was loaded.

 

337

             Not necessarily the last-changed revision for this file.

 

338

        :param inv: Inventory from which the entry was loaded.

 

339

        :param tree: RevisionTree for this entry.

292

340

        """

293

341

        if self.parent_id != None:

294

342

            if not inv.has_id(self.parent_id):

301

349

        raise BzrCheckError('unknown entry kind %r in revision {%s}' % 

302

350

                            (self.kind, rev_id))

303

351

 

304

 

 

305

352

    def copy(self):

306

353

        """Clone this inventory entry."""

307

354

        raise NotImplementedError

308

355

 

309

 

    def _get_snapshot_change(self, previous_entries):

 

356

    def _describe_snapshot_change(self, previous_entries):

 

357

        """Describe how this entry will have changed in a new commit.

 

358

 

 

359

        :param previous_entries: Dictionary from revision_id to inventory entry.

 

360

 

 

361

        :returns: One-word description: "merged", "added", "renamed", "modified".

 

362

        """

 

363

        # XXX: This assumes that the file *has* changed -- it should probably

 

364

        # be fused with whatever does that detection.  Why not just a single

 

365

        # thing to compare the entries?

 

366

        #

 

367

        # TODO: Return some kind of object describing all the possible

 

368

        # dimensions that can change, not just a string.  That can then give

 

369

        # both old and new names for renames, etc.

 

370

        #

310

371

        if len(previous_entries) > 1:

311

372

            return 'merged'

312

373

        elif len(previous_entries) == 0:

313

374

            return 'added'

314

 

        else:

315

 

            return 'modified/renamed/reparented'

 

375

        the_parent, = previous_entries.values()

 

376

        if self.parent_id != the_parent.parent_id:

 

377

            # actually, moved to another directory

 

378

            return 'renamed'

 

379

        elif self.name != the_parent.name:

 

380

            return 'renamed'

 

381

        return 'modified'

316

382

 

317

383

    def __repr__(self):

318

384

        return ("%s(%r, %r, parent_id=%r)"

337

403

                mutter("found unchanged entry")

338

404

                self.revision = parent_ie.revision

339

405

                return "unchanged"

340

 

        return self.snapshot_revision(revision, previous_entries, 

341

 

                                      work_tree, weave_store, transaction)

342

 

 

343

 

    def snapshot_revision(self, revision, previous_entries, work_tree,

344

 

                          weave_store, transaction):

345

 

        """Record this revision unconditionally."""

346

 

        mutter('new revision for {%s}', self.file_id)

 

406

        return self._snapshot_into_revision(revision, previous_entries, 

 

407

                                            work_tree, weave_store, transaction)

 

408

 

 

409

    def _snapshot_into_revision(self, revision, previous_entries, work_tree,

 

410

                                weave_store, transaction):

 

411

        """Record this revision unconditionally into a store.

 

412

 

 

413

        The entry's last-changed revision property (`revision`) is updated to 

 

414

        that of the new revision.

 

415

        

 

416

        :param revision: id of the new revision that is being recorded.

 

417

 

 

418

        :returns: String description of the commit (e.g. "merged", "modified"), etc.

 

419

        """

 

420

        mutter('new revision {%s} for {%s}', revision, self.file_id)

347

421

        self.revision = revision

348

 

        change = self._get_snapshot_change(previous_entries)

 

422

        change = self._describe_snapshot_change(previous_entries)

349

423

        self._snapshot_text(previous_entries, work_tree, weave_store,

350

424

                            transaction)

351

425

        return change

472

546

class InventoryFile(InventoryEntry):

473

547

    """A file in an inventory."""

474

548

 

475

 

    def _check(self, checker, rev_id, tree):

 

549

    def _check(self, checker, tree_revision_id, tree):

476

550

        """See InventoryEntry._check"""

477

 

        revision = self.revision

478

 

        t = (self.file_id, revision)

 

551

        t = (self.file_id, self.revision)

479

552

        if t in checker.checked_texts:

480

 

            prev_sha = checker.checked_texts[t] 

 

553

            prev_sha = checker.checked_texts[t]

481

554

            if prev_sha != self.text_sha1:

482

555

                raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %

483

 

                                    (self.file_id, rev_id))

 

556

                                    (self.file_id, tree_revision_id))

484

557

            else:

485

558

                checker.repeated_text_cnt += 1

486

559

                return

496

569

        else:

497

570

            w = tree.get_weave(self.file_id)

498

571

 

499

 

        mutter('check version {%s} of {%s}', rev_id, self.file_id)

500

 

        checker.checked_text_cnt += 1 

 

572

        mutter('check version {%s} of {%s}', tree_revision_id, self.file_id)

 

573

        checker.checked_text_cnt += 1

501

574

        # We can't check the length, because Weave doesn't store that

502

575

        # information, and the whole point of looking at the weave's

503

576

        # sha1sum is that we don't have to extract the text.

526

599

    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,

527

600

             output_to, reverse=False):

528

601

        """See InventoryEntry._diff."""

529

 

        from_text = tree.get_file(self.file_id).readlines()

530

 

        if to_entry:

531

 

            to_text = to_tree.get_file(to_entry.file_id).readlines()

532

 

        else:

533

 

            to_text = []

534

 

        if not reverse:

535

 

            text_diff(from_label, from_text,

536

 

                      to_label, to_text, output_to)

537

 

        else:

538

 

            text_diff(to_label, to_text,

539

 

                      from_label, from_text, output_to)

 

602

        try:

 

603

            from_text = tree.get_file(self.file_id).readlines()

 

604

            if to_entry:

 

605

                to_text = to_tree.get_file(to_entry.file_id).readlines()

 

606

            else:

 

607

                to_text = []

 

608

            if not reverse:

 

609

                text_diff(from_label, from_text,

 

610

                          to_label, to_text, output_to)

 

611

            else:

 

612

                text_diff(to_label, to_text,

 

613

                          from_label, from_text, output_to)

 

614

        except BinaryFile:

 

615

            if reverse:

 

616

                label_pair = (to_label, from_label)

 

617

            else:

 

618

                label_pair = (from_label, to_label)

 

619

            print >> output_to, "Binary files %s and %s differ" % label_pair

540

620

 

541

621

    def has_text(self):

542

622

        """See InventoryEntry.has_text."""

733

813

    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))

734

814

    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678')

735

815

    """

736

 

    def __init__(self, root_id=ROOT_ID):

 

816

    def __init__(self, root_id=ROOT_ID, revision_id=None):

737

817

        """Create or read an inventory.

738

818

 

739

819

        If a working directory is specified, the inventory is read

748

828

        #if root_id is None:

749

829

        #    root_id = bzrlib.branch.gen_file_id('TREE_ROOT')

750

830

        self.root = RootEntry(root_id)

 

831

        self.revision_id = revision_id

751

832

        self._byid = {self.root.file_id: self.root}

752

833

 

753

834

 

754

835

    def copy(self):

 

836

        # TODO: jam 20051218 Should copy also copy the revision_id?

755

837

        other = Inventory(self.root.file_id)

756

838

        # copy recursively so we know directories will be added before

757

839

        # their children.  There are more efficient ways than this...

980

1062

    def __hash__(self):

981

1063

        raise ValueError('not hashable')

982

1064

 

 

1065

    def _iter_file_id_parents(self, file_id):

 

1066

        """Yield the parents of file_id up to the root."""

 

1067

        while file_id != None:

 

1068

            try:

 

1069

                ie = self._byid[file_id]

 

1070

            except KeyError:

 

1071

                raise BzrError("file_id {%s} not found in inventory" % file_id)

 

1072

            yield ie

 

1073

            file_id = ie.parent_id

983

1074

 

984

1075

    def get_idpath(self, file_id):

985

1076

        """Return a list of file_ids for the path to an entry.

990

1081

        root directory as depth 1.

991

1082

        """

992

1083

        p = []

993

 

        while file_id != None:

994

 

            try:

995

 

                ie = self._byid[file_id]

996

 

            except KeyError:

997

 

                raise BzrError("file_id {%s} not found in inventory" % file_id)

998

 

            p.insert(0, ie.file_id)

999

 

            file_id = ie.parent_id

 

1084

        for parent in self._iter_file_id_parents(file_id):

 

1085

            p.insert(0, parent.file_id)

1000

1086

        return p

1001

1087

 

1002

 

 

1003

1088

    def id2path(self, file_id):

1004

 

        """Return as a list the path to file_id.

 

1089

        """Return as a string the path to file_id.

1005

1090

        

1006

1091

        >>> i = Inventory()

1007

1092

        >>> e = i.add(InventoryDirectory('src-id', 'src', ROOT_ID))

1010

1095

        src/foo.c

1011

1096

        """

1012

1097

        # get all names, skipping root

1013

 

        p = [self._byid[fid].name for fid in self.get_idpath(file_id)[1:]]

1014

 

        if p:

1015

 

            return pathjoin(*p)

1016

 

        else:

1017

 

            return ''

 

1098

        return '/'.join(reversed(

 

1099

            [parent.name for parent in 

 

1100

             self._iter_file_id_parents(file_id)][:-1]))

1018

1101

            

1019

 

 

1020

 

 

1021

1102

    def path2id(self, name):

1022

1103

        """Walk down through directories to return entry of last component.

1023

1104

 

• Older »

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