~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

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

• reverse the comparison (4797.22.1 to 4577.2.1)
• stop comparing with revision 4577.2.1

Show diffs side-by-side

added

removed

bzrlib/tree.py

1

 

# Copyright (C) 2005, 2009 Canonical Ltd

 

1

# Copyright (C) 2005-2010 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

170

170

        return self.bzrdir.is_control_filename(filename)

171

171

 

172

172

    @needs_read_lock

173

 

    def iter_entries_by_dir(self, specific_file_ids=None):

 

173

    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):

174

174

        """Walk the tree in 'by_dir' order.

175

175

 

176

176

        This will yield each entry in the tree as a (path, entry) tuple.

193

193

 

194

194

        The yield order (ignoring root) would be::

195

195

          a, f, a/b, a/d, a/b/c, a/d/e, f/g

 

196

 

 

197

        :param yield_parents: If True, yield the parents from the root leading

 

198

            down to specific_file_ids that have been requested. This has no

 

199

            impact if specific_file_ids is None.

196

200

        """

197

201

        return self.inventory.iter_entries_by_dir(

198

 

            specific_file_ids=specific_file_ids)

 

202

            specific_file_ids=specific_file_ids, yield_parents=yield_parents)

199

203

 

200

204

    def iter_references(self):

201

205

        if self.supports_tree_reference():

218

222

    def path_content_summary(self, path):

219

223

        """Get a summary of the information about path.

220

224

 

 

225

        All the attributes returned are for the canonical form, not the

 

226

        convenient form (if content filters are in use.)

 

227

 

221

228

        :param path: A relative path within the tree.

222

229

        :return: A tuple containing kind, size, exec, sha1-or-link.

223

230

            Kind is always present (see tree.kind()).

224

 

            size is present if kind is file, None otherwise.

 

231

            size is present if kind is file and the size of the 

 

232

                canonical form can be cheaply determined, None otherwise.

225

233

            exec is None unless kind is file and the platform supports the 'x'

226

234

                bit.

227

235

            sha1-or-link is the link target if kind is symlink, or the sha1 if

396

404

            bit_iter = iter(path.split("/"))

397

405

            for elt in bit_iter:

398

406

                lelt = elt.lower()

 

407

                new_path = None

399

408

                for child in self.iter_children(cur_id):

400

409

                    try:

 

410

                        # XXX: it seem like if the child is known to be in the

 

411

                        # tree, we shouldn't need to go from its id back to

 

412

                        # its path -- mbp 2010-02-11

 

413

                        #

 

414

                        # XXX: it seems like we could be more efficient

 

415

                        # by just directly looking up the original name and

 

416

                        # only then searching all children; also by not

 

417

                        # chopping paths so much. -- mbp 2010-02-11

401

418

                        child_base = os.path.basename(self.id2path(child))

402

 

                        if child_base.lower() == lelt:

 

419

                        if (child_base == elt):

 

420

                            # if we found an exact match, we can stop now; if

 

421

                            # we found an approximate match we need to keep

 

422

                            # searching because there might be an exact match

 

423

                            # later.  

403

424

                            cur_id = child

404

 

                            cur_path = osutils.pathjoin(cur_path, child_base)

 

425

                            new_path = osutils.pathjoin(cur_path, child_base)

405

426

                            break

 

427

                        elif child_base.lower() == lelt:

 

428

                            cur_id = child

 

429

                            new_path = osutils.pathjoin(cur_path, child_base)

406

430

                    except NoSuchId:

407

431

                        # before a change is committed we can see this error...

408

432

                        continue

 

433

                if new_path:

 

434

                    cur_path = new_path

409

435

                else:

410

436

                    # got to the end of this directory and no entries matched.

411

437

                    # Return what matched so far, plus the rest as specified.

689

715

                for path in path_names:

690

716

                    yield searcher.get_items(path)

691

717

 

692

 

    @needs_read_lock

693

718

    def _get_rules_searcher(self, default_searcher):

694

719

        """Get the RulesSearcher for this tree given the default one."""

695

720

        searcher = default_searcher

844

869

    will pass through to InterTree as appropriate.

845

870

    """

846

871

 

 

872

    # Formats that will be used to test this InterTree. If both are

 

873

    # None, this InterTree will not be tested (e.g. because a complex

 

874

    # setup is required)

 

875

    _matching_from_tree_format = None

 

876

    _matching_to_tree_format = None

 

877

 

847

878

    _optimisers = []

848

879

 

 

880

    def _changes_from_entries(self, source_entry, target_entry,

 

881

        source_path=None, target_path=None):

 

882

        """Generate a iter_changes tuple between source_entry and target_entry.

 

883

 

 

884

        :param source_entry: An inventory entry from self.source, or None.

 

885

        :param target_entry: An inventory entry from self.target, or None.

 

886

        :param source_path: The path of source_entry, if known. If not known

 

887

            it will be looked up.

 

888

        :param target_path: The path of target_entry, if known. If not known

 

889

            it will be looked up.

 

890

        :return: A tuple, item 0 of which is an iter_changes result tuple, and

 

891

            item 1 is True if there are any changes in the result tuple.

 

892

        """

 

893

        if source_entry is None:

 

894

            if target_entry is None:

 

895

                return None

 

896

            file_id = target_entry.file_id

 

897

        else:

 

898

            file_id = source_entry.file_id

 

899

        if source_entry is not None:

 

900

            source_versioned = True

 

901

            source_name = source_entry.name

 

902

            source_parent = source_entry.parent_id

 

903

            if source_path is None:

 

904

                source_path = self.source.id2path(file_id)

 

905

            source_kind, source_executable, source_stat = \

 

906

                self.source._comparison_data(source_entry, source_path)

 

907

        else:

 

908

            source_versioned = False

 

909

            source_name = None

 

910

            source_parent = None

 

911

            source_kind = None

 

912

            source_executable = None

 

913

        if target_entry is not None:

 

914

            target_versioned = True

 

915

            target_name = target_entry.name

 

916

            target_parent = target_entry.parent_id

 

917

            if target_path is None:

 

918

                target_path = self.target.id2path(file_id)

 

919

            target_kind, target_executable, target_stat = \

 

920

                self.target._comparison_data(target_entry, target_path)

 

921

        else:

 

922

            target_versioned = False

 

923

            target_name = None

 

924

            target_parent = None

 

925

            target_kind = None

 

926

            target_executable = None

 

927

        versioned = (source_versioned, target_versioned)

 

928

        kind = (source_kind, target_kind)

 

929

        changed_content = False

 

930

        if source_kind != target_kind:

 

931

            changed_content = True

 

932

        elif source_kind == 'file':

 

933

            if (self.source.get_file_sha1(file_id, source_path, source_stat) !=

 

934

                self.target.get_file_sha1(file_id, target_path, target_stat)):

 

935

                changed_content = True

 

936

        elif source_kind == 'symlink':

 

937

            if (self.source.get_symlink_target(file_id) !=

 

938

                self.target.get_symlink_target(file_id)):

 

939

                changed_content = True

 

940

            # XXX: Yes, the indentation below is wrong. But fixing it broke

 

941

            # test_merge.TestMergerEntriesLCAOnDisk.

 

942

            # test_nested_tree_subtree_renamed_and_modified. We'll wait for

 

943

            # the fix from bzr.dev -- vila 2009026

 

944

            elif source_kind == 'tree-reference':

 

945

                if (self.source.get_reference_revision(file_id, source_path)

 

946

                    != self.target.get_reference_revision(file_id, target_path)):

 

947

                    changed_content = True

 

948

        parent = (source_parent, target_parent)

 

949

        name = (source_name, target_name)

 

950

        executable = (source_executable, target_executable)

 

951

        if (changed_content is not False or versioned[0] != versioned[1]

 

952

            or parent[0] != parent[1] or name[0] != name[1] or

 

953

            executable[0] != executable[1]):

 

954

            changes = True

 

955

        else:

 

956

            changes = False

 

957

        return (file_id, (source_path, target_path), changed_content,

 

958

                versioned, parent, name, kind, executable), changes

 

959

 

849

960

    @needs_read_lock

850

961

    def compare(self, want_unchanged=False, specific_files=None,

851

962

        extra_trees=None, require_versioned=False, include_root=False,

866

977

            a PathsNotVersionedError will be thrown.

867

978

        :param want_unversioned: Scan for unversioned paths.

868

979

        """

869

 

        # NB: show_status depends on being able to pass in non-versioned files

870

 

        # and report them as unknown

871

980

        trees = (self.source,)

872

981

        if extra_trees is not None:

873

982

            trees = trees + tuple(extra_trees)

914

1023

        :param require_versioned: Raise errors.PathsNotVersionedError if a

915

1024

            path in the specific_files list is not versioned in one of

916

1025

            source, target or extra_trees.

 

1026

        :param specific_files: An optional list of file paths to restrict the

 

1027

            comparison to. When mapping filenames to ids, all matches in all

 

1028

            trees (including optional extra_trees) are used, and all children

 

1029

            of matched directories are included. The parents in the target tree

 

1030

            of the specific files up to and including the root of the tree are

 

1031

            always evaluated for changes too.

917

1032

        :param want_unversioned: Should unversioned files be returned in the

918

1033

            output. An unversioned file is defined as one with (False, False)

919

1034

            for the versioned pair.

921

1036

        lookup_trees = [self.source]

922

1037

        if extra_trees:

923

1038

             lookup_trees.extend(extra_trees)

 

1039

        # The ids of items we need to examine to insure delta consistency.

 

1040

        precise_file_ids = set()

 

1041

        changed_file_ids = []

924

1042

        if specific_files == []:

925

1043

            specific_file_ids = []

926

1044

        else:

927

1045

            specific_file_ids = self.target.paths2ids(specific_files,

928

1046

                lookup_trees, require_versioned=require_versioned)

 

1047

        if specific_files is not None:

 

1048

            # reparented or added entries must have their parents included

 

1049

            # so that valid deltas can be created. The seen_parents set

 

1050

            # tracks the parents that we need to have.

 

1051

            # The seen_dirs set tracks directory entries we've yielded.

 

1052

            # After outputting version object in to_entries we set difference

 

1053

            # the two seen sets and start checking parents.

 

1054

            seen_parents = set()

 

1055

            seen_dirs = set()

929

1056

        if want_unversioned:

930

1057

            all_unversioned = sorted([(p.split('/'), p) for p in

931

1058

                                     self.target.extras()

946

1073

        # can be extras. So the fake_entry is solely used to look up

947

1074

        # executable it values when execute is not supported.

948

1075

        fake_entry = InventoryFile('unused', 'unused', 'unused')

949

 

        for to_path, to_entry in to_entries_by_dir:

950

 

            while all_unversioned and all_unversioned[0][0] < to_path.split('/'):

 

1076

        for target_path, target_entry in to_entries_by_dir:

 

1077

            while (all_unversioned and

 

1078

                all_unversioned[0][0] < target_path.split('/')):

951

1079

                unversioned_path = all_unversioned.popleft()

952

 

                to_kind, to_executable, to_stat = \

 

1080

                target_kind, target_executable, target_stat = \

953

1081

                    self.target._comparison_data(fake_entry, unversioned_path[1])

954

1082

                yield (None, (None, unversioned_path[1]), True, (False, False),

955

1083

                    (None, None),

956

1084

                    (None, unversioned_path[0][-1]),

957

 

                    (None, to_kind),

958

 

                    (None, to_executable))

959

 

            file_id = to_entry.file_id

960

 

            to_paths[file_id] = to_path

 

1085

                    (None, target_kind),

 

1086

                    (None, target_executable))

 

1087

            source_path, source_entry = from_data.get(target_entry.file_id,

 

1088

                (None, None))

 

1089

            result, changes = self._changes_from_entries(source_entry,

 

1090

                target_entry, source_path=source_path, target_path=target_path)

 

1091

            to_paths[result[0]] = result[1][1]

961

1092

            entry_count += 1

962

 

            changed_content = False

963

 

            from_path, from_entry = from_data.get(file_id, (None, None))

964

 

            from_versioned = (from_entry is not None)

965

 

            if from_entry is not None:

966

 

                from_versioned = True

967

 

                from_name = from_entry.name

968

 

                from_parent = from_entry.parent_id

969

 

                from_kind, from_executable, from_stat = \

970

 

                    self.source._comparison_data(from_entry, from_path)

 

1093

            if result[3][0]:

971

1094

                entry_count += 1

972

 

            else:

973

 

                from_versioned = False

974

 

                from_kind = None

975

 

                from_parent = None

976

 

                from_name = None

977

 

                from_executable = None

978

 

            versioned = (from_versioned, True)

979

 

            to_kind, to_executable, to_stat = \

980

 

                self.target._comparison_data(to_entry, to_path)

981

 

            kind = (from_kind, to_kind)

982

 

            if kind[0] != kind[1]:

983

 

                changed_content = True

984

 

            elif from_kind == 'file':

985

 

                if (self.source.get_file_sha1(file_id, from_path, from_stat) !=

986

 

                    self.target.get_file_sha1(file_id, to_path, to_stat)):

987

 

                    changed_content = True

988

 

            elif from_kind == 'symlink':

989

 

                if (self.source.get_symlink_target(file_id) !=

990

 

                    self.target.get_symlink_target(file_id)):

991

 

                    changed_content = True

992

 

                # XXX: Yes, the indentation below is wrong. But fixing it broke

993

 

                # test_merge.TestMergerEntriesLCAOnDisk.

994

 

                # test_nested_tree_subtree_renamed_and_modified. We'll wait for

995

 

                # the fix from bzr.dev -- vila 2009026

996

 

                elif from_kind == 'tree-reference':

997

 

                    if (self.source.get_reference_revision(file_id, from_path)

998

 

                        != self.target.get_reference_revision(file_id, to_path)):

999

 

                        changed_content = True

1000

 

            parent = (from_parent, to_entry.parent_id)

1001

 

            name = (from_name, to_entry.name)

1002

 

            executable = (from_executable, to_executable)

1003

1095

            if pb is not None:

1004

1096

                pb.update('comparing files', entry_count, num_entries)

1005

 

            if (changed_content is not False or versioned[0] != versioned[1]

1006

 

                or parent[0] != parent[1] or name[0] != name[1] or

1007

 

                executable[0] != executable[1] or include_unchanged):

1008

 

                yield (file_id, (from_path, to_path), changed_content,

1009

 

                    versioned, parent, name, kind, executable)

1010

 

 

 

1097

            if changes or include_unchanged:

 

1098

                if specific_file_ids is not None:

 

1099

                    new_parent_id = result[4][1]

 

1100

                    precise_file_ids.add(new_parent_id)

 

1101

                    changed_file_ids.append(result[0])

 

1102

                yield result

 

1103

            # Ensure correct behaviour for reparented/added specific files.

 

1104

            if specific_files is not None:

 

1105

                # Record output dirs

 

1106

                if result[6][1] == 'directory':

 

1107

                    seen_dirs.add(result[0])

 

1108

                # Record parents of reparented/added entries.

 

1109

                versioned = result[3]

 

1110

                parents = result[4]

 

1111

                if not versioned[0] or parents[0] != parents[1]:

 

1112

                    seen_parents.add(parents[1])

1011

1113

        while all_unversioned:

1012

1114

            # yield any trailing unversioned paths

1013

1115

            unversioned_path = all_unversioned.popleft()

1018

1120

                (None, unversioned_path[0][-1]),

1019

1121

                (None, to_kind),

1020

1122

                (None, to_executable))

1021

 

 

1022

 

        def get_to_path(to_entry):

1023

 

            if to_entry.parent_id is None:

1024

 

                to_path = '' # the root

1025

 

            else:

1026

 

                if to_entry.parent_id not in to_paths:

1027

 

                    # recurse up

1028

 

                    return get_to_path(self.target.inventory[to_entry.parent_id])

1029

 

                to_path = osutils.pathjoin(to_paths[to_entry.parent_id],

1030

 

                                           to_entry.name)

1031

 

            to_paths[to_entry.file_id] = to_path

1032

 

            return to_path

1033

 

 

 

1123

        # Yield all remaining source paths

1034

1124

        for path, from_entry in from_entries_by_dir:

1035

1125

            file_id = from_entry.file_id

1036

1126

            if file_id in to_paths:

1037

1127

                # already returned

1038

1128

                continue

1039

 

            if not file_id in self.target.all_file_ids():

 

1129

            if file_id not in self.target.all_file_ids():

1040

1130

                # common case - paths we have not emitted are not present in

1041

1131

                # target.

1042

1132

                to_path = None

1043

1133

            else:

1044

 

                to_path = get_to_path(self.target.inventory[file_id])

 

1134

                to_path = self.target.id2path(file_id)

1045

1135

            entry_count += 1

1046

1136

            if pb is not None:

1047

1137

                pb.update('comparing files', entry_count, num_entries)

1054

1144

            executable = (from_executable, None)

1055

1145

            changed_content = from_kind is not None

1056

1146

            # the parent's path is necessarily known at this point.

 

1147

            changed_file_ids.append(file_id)

1057

1148

            yield(file_id, (path, to_path), changed_content, versioned, parent,

1058

1149

                  name, kind, executable)

 

1150

        changed_file_ids = set(changed_file_ids)

 

1151

        if specific_file_ids is not None:

 

1152

            for result in self._handle_precise_ids(precise_file_ids,

 

1153

                changed_file_ids):

 

1154

                yield result

 

1155

 

 

1156

    def _get_entry(self, tree, file_id):

 

1157

        """Get an inventory entry from a tree, with missing entries as None.

 

1158

 

 

1159

        If the tree raises NotImplementedError on accessing .inventory, then

 

1160

        this is worked around using iter_entries_by_dir on just the file id

 

1161

        desired.

 

1162

 

 

1163

        :param tree: The tree to lookup the entry in.

 

1164

        :param file_id: The file_id to lookup.

 

1165

        """

 

1166

        try:

 

1167

            inventory = tree.inventory

 

1168

        except NotImplementedError:

 

1169

            # No inventory available.

 

1170

            try:

 

1171

                iterator = tree.iter_entries_by_dir(specific_file_ids=[file_id])

 

1172

                return iterator.next()[1]

 

1173

            except StopIteration:

 

1174

                return None

 

1175

        else:

 

1176

            try:

 

1177

                return inventory[file_id]

 

1178

            except errors.NoSuchId:

 

1179

                return None

 

1180

 

 

1181

    def _handle_precise_ids(self, precise_file_ids, changed_file_ids,

 

1182

        discarded_changes=None):

 

1183

        """Fill out a partial iter_changes to be consistent.

 

1184

 

 

1185

        :param precise_file_ids: The file ids of parents that were seen during

 

1186

            the iter_changes.

 

1187

        :param changed_file_ids: The file ids of already emitted items.

 

1188

        :param discarded_changes: An optional dict of precalculated

 

1189

            iter_changes items which the partial iter_changes had not output

 

1190

            but had calculated.

 

1191

        :return: A generator of iter_changes items to output.

 

1192

        """

 

1193

        # process parents of things that had changed under the users

 

1194

        # requested paths to prevent incorrect paths or parent ids which

 

1195

        # aren't in the tree.

 

1196

        while precise_file_ids:

 

1197

            precise_file_ids.discard(None)

 

1198

            # Don't emit file_ids twice

 

1199

            precise_file_ids.difference_update(changed_file_ids)

 

1200

            if not precise_file_ids:

 

1201

                break

 

1202

            # If the there was something at a given output path in source, we

 

1203

            # have to include the entry from source in the delta, or we would

 

1204

            # be putting this entry into a used path.

 

1205

            paths = []

 

1206

            for parent_id in precise_file_ids:

 

1207

                try:

 

1208

                    paths.append(self.target.id2path(parent_id))

 

1209

                except errors.NoSuchId:

 

1210

                    # This id has been dragged in from the source by delta

 

1211

                    # expansion and isn't present in target at all: we don't

 

1212

                    # need to check for path collisions on it.

 

1213

                    pass

 

1214

            for path in paths:

 

1215

                old_id = self.source.path2id(path)

 

1216

                precise_file_ids.add(old_id)

 

1217

            precise_file_ids.discard(None)

 

1218

            current_ids = precise_file_ids

 

1219

            precise_file_ids = set()

 

1220

            # We have to emit all of precise_file_ids that have been altered.

 

1221

            # We may have to output the children of some of those ids if any

 

1222

            # directories have stopped being directories.

 

1223

            for file_id in current_ids:

 

1224

                # Examine file_id

 

1225

                if discarded_changes:

 

1226

                    result = discarded_changes.get(file_id)

 

1227

                    old_entry = None

 

1228

                else:

 

1229

                    result = None

 

1230

                if result is None:

 

1231

                    old_entry = self._get_entry(self.source, file_id)

 

1232

                    new_entry = self._get_entry(self.target, file_id)

 

1233

                    result, changes = self._changes_from_entries(

 

1234

                        old_entry, new_entry)

 

1235

                else:

 

1236

                    changes = True

 

1237

                # Get this parents parent to examine.

 

1238

                new_parent_id = result[4][1]

 

1239

                precise_file_ids.add(new_parent_id)

 

1240

                if changes:

 

1241

                    if (result[6][0] == 'directory' and

 

1242

                        result[6][1] != 'directory'):

 

1243

                        # This stopped being a directory, the old children have

 

1244

                        # to be included.

 

1245

                        if old_entry is None:

 

1246

                            # Reusing a discarded change.

 

1247

                            old_entry = self._get_entry(self.source, file_id)

 

1248

                        for child in old_entry.children.values():

 

1249

                            precise_file_ids.add(child.file_id)

 

1250

                    changed_file_ids.add(result[0])

 

1251

                    yield result

1059

1252

 

1060

1253

 

1061

1254

class MultiWalker(object):

• Older »

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