← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/add.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-05-23 00:18:26 UTC
  • mfrom: (1724.1.1 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060523001826-458fe69c27fc17a7
Merge bzr add performance improvements. (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/add.py
51
51
    return file_list
52
52
 
53
53
 
54
 
def add_action_null(inv, path, kind):
 
54
def add_action_null(inv, parent_ie, path, kind):
55
55
    """Absorb add actions and do nothing."""
56
56
    pass
57
57
 
58
 
def add_action_print(inv, path, kind):
 
58
 
 
59
def add_action_print(inv, parent_ie, path, kind):
59
60
    """Print a line to stdout for each file that would be added."""
60
61
    print "added", bzrlib.osutils.quotefn(path)
61
62
 
62
 
def add_action_add(inv, path, kind):
 
63
 
 
64
def add_action_add(inv, parent_ie, path, kind):
63
65
    """Add each file to the given inventory. Produce no output."""
64
 
    entry = inv.add_path(path, kind=kind)
65
 
    mutter("added %r kind %r file_id={%s}" % (path, kind, entry.file_id))
66
 
 
67
 
 
68
 
def add_action_add_and_print(inv, path, kind):
 
66
    if parent_ie is not None:
 
67
        entry = bzrlib.inventory.make_entry(
 
68
            kind, bzrlib.osutils.basename(path),  parent_ie.file_id)
 
69
        inv.add(entry)
 
70
    else:
 
71
        entry = inv.add_path(path, kind=kind)
 
72
    # mutter("added %r kind %r file_id={%s}" % (path, kind, entry.file_id))
 
73
 
 
74
 
 
75
def add_action_add_and_print(inv, parent_ie, path, kind):
69
76
    """Add each file to the given inventory, and print a line to stdout."""
70
 
    add_action_add(inv, path, kind)
71
 
    add_action_print(inv, path, kind)
 
77
    add_action_add(inv, parent_ie, path, kind)
 
78
    add_action_print(inv, parent_ie, path, kind)
72
79
 
73
80
 
74
81
def smart_add(file_list, recurse=True, action=add_action_add):
98
105
    from bzrlib.errors import BadFileKindError, ForbiddenFileError
99
106
    assert isinstance(recurse, bool)
100
107
    
101
 
    orig_list = file_list
102
 
    file_list = _prepare_file_list(file_list)
103
 
    mutter("smart add of %r, originally %r", file_list, orig_list)
 
108
    prepared_list = _prepare_file_list(file_list)
 
109
    mutter("smart add of %r, originally %r", prepared_list, file_list)
104
110
    inv = tree.read_working_inventory()
105
111
    added = []
106
112
    ignored = {}
107
 
    user_files = set(file_list)
 
113
    user_files = set()
 
114
    files_to_add = []
108
115
 
109
 
    for filepath in file_list:
110
 
        # convert a random abs or cwd-relative path to tree relative.
 
116
    # validate user file paths and convert all paths to tree 
 
117
    # relative : its cheaper to make a tree relative path an abspath
 
118
    # than to convert an abspath to tree relative.
 
119
    for filepath in prepared_list:
111
120
        rf = tree.relpath(filepath)
112
 
 
 
121
        user_files.add(rf)
 
122
        files_to_add.append((rf, None))
113
123
        # validate user parameters. Our recursive code avoids adding new files
114
124
        # that need such validation 
115
 
        if filepath in user_files and tree.is_control_filename(rf):
 
125
        if tree.is_control_filename(rf):
116
126
            raise ForbiddenFileError('cannot add control file %s' % filepath)
117
127
 
 
128
    for filepath, parent_ie in files_to_add:
 
129
        # filepath is tree-relative
 
130
        abspath = tree.abspath(filepath)
 
131
 
118
132
        # find the kind of the path being added. This is not
119
133
        # currently determined when we list directories 
120
134
        # recursively, but in theory we can determine while 
125
139
        # it is defined. (Apparently Mac OSX has the field but
126
140
        # does not fill it in ?!) Robert C, Martin P.
127
141
        try:
128
 
            kind = bzrlib.osutils.file_kind(filepath)
 
142
            kind = bzrlib.osutils.file_kind(abspath)
129
143
        except OSError, e:
130
144
            if hasattr(e, 'errno') and e.errno == errno.ENOENT:
131
 
                raise errors.NoSuchFile(filepath)
 
145
                raise errors.NoSuchFile(abspath)
132
146
            raise
133
147
 
134
148
        # we need to call this to determine the inventory kind to create.
135
149
        if not InventoryEntry.versionable_kind(kind):
136
150
            if filepath in user_files:
137
 
                raise BadFileKindError("cannot add %s of type %s" % (filepath, kind))
 
151
                raise BadFileKindError("cannot add %s of type %s" % (abspath, kind))
138
152
            else:
139
 
                warning("skipping %s (can't add file of kind '%s')", filepath, kind)
 
153
                warning("skipping %s (can't add file of kind '%s')", abspath, kind)
140
154
                continue
141
155
 
142
 
        # TODO make has_filename faster or provide a better api for accessing/determining 
143
 
        # this status. perhaps off the inventory directory object.
144
 
        versioned = inv.has_filename(rf)
 
156
        if parent_ie is not None:
 
157
            versioned = bzrlib.osutils.basename(filepath) in parent_ie.children
 
158
        else:
 
159
            # without the parent ie, use the relatively slower inventory 
 
160
            # probing method
 
161
            versioned = inv.has_filename(filepath)
145
162
 
146
163
        if kind == 'directory':
147
164
            try:
148
 
                sub_branch = bzrlib.bzrdir.BzrDir.open(filepath)
 
165
                sub_branch = bzrlib.bzrdir.BzrDir.open(abspath)
149
166
                sub_tree = True
150
167
            except NotBranchError:
151
168
                sub_tree = False
154
171
        else:
155
172
            sub_tree = False
156
173
 
157
 
        if rf == '':
 
174
        if filepath == '':
158
175
            # mutter("tree root doesn't need to be added")
159
176
            sub_tree = False
160
177
        elif versioned:
161
178
            pass
162
 
            # mutter("%r is already versioned", filepath)
 
179
            # mutter("%r is already versioned", abspath)
163
180
        elif sub_tree:
164
 
            mutter("%r is a nested bzr tree", filepath)
 
181
            mutter("%r is a nested bzr tree", abspath)
165
182
        else:
166
 
            added.extend(__add_one(tree, inv, rf, kind, action))
 
183
            added.extend(__add_one(tree, inv, parent_ie, filepath, kind, action))
167
184
 
168
185
        if kind == 'directory' and recurse and not sub_tree:
169
 
            for subf in os.listdir(filepath):
 
186
            try:
 
187
                if parent_ie is not None:
 
188
                    # must be present:
 
189
                    this_ie = parent_ie.children[bzrlib.osutils.basename(filepath)]
 
190
                else:
 
191
                    # without the parent ie, use the relatively slower inventory 
 
192
                    # probing method
 
193
                    this_id = inv.path2id(filepath)
 
194
                    if this_id is None:
 
195
                        this_ie = None
 
196
                    else:
 
197
                        this_ie = inv[this_id]
 
198
            except KeyError:
 
199
                this_ie = None
 
200
 
 
201
            for subf in os.listdir(abspath):
170
202
                # here we could use TreeDirectory rather than 
171
203
                # string concatenation.
172
 
                subp = bzrlib.osutils.pathjoin(rf, subf)
 
204
                subp = bzrlib.osutils.pathjoin(filepath, subf)
173
205
                # TODO: is_control_filename is very slow. Make it faster. 
174
206
                # TreeDirectory.is_control_filename could also make this 
175
207
                # faster - its impossible for a non root dir to have a 
187
219
                        ignored[ignore_glob].append(subp)
188
220
                    else:
189
221
                        #mutter("queue to add sub-file %r", subp)
190
 
                        file_list.append(tree.abspath(subp))
 
222
                        files_to_add.append((subp, this_ie))
191
223
 
192
224
    if len(added) > 0:
193
225
        tree._write_inventory(inv)
194
226
    return added, ignored
195
227
 
196
228
 
197
 
def __add_one(tree, inv, path, kind, action):
198
 
    """Add a file or directory, automatically add unversioned parents."""
 
229
def __add_one(tree, inv, parent_ie, path, kind, action):
 
230
    """Add a new entry to the inventory and automatically add unversioned parents.
 
231
 
 
232
    Actual adding of the entry is delegated to the action callback.
 
233
 
 
234
    :param inv: Inventory which will receive the new entry.
 
235
    :param parent_ie: Parent inventory entry if known, or None.  If
 
236
    None, the parent is looked up by name and used if present, otherwise
 
237
    it is recursively added.
 
238
    :param kind: Kind of new entry (file, directory, etc)
 
239
    :param action: callback(inv, parent_ie, path, kind); return ignored.
 
240
    :returns: A list of paths which have been added.
 
241
    """
199
242
 
200
243
    # Nothing to do if path is already versioned.
201
244
    # This is safe from infinite recursion because the tree root is
202
245
    # always versioned.
203
 
    if inv.path2id(path) != None:
204
 
        return []
205
 
 
206
 
    # add parent
207
 
    added = __add_one(tree, inv, dirname(path), 'directory', action)
208
 
    action(inv, path, kind)
 
246
    if parent_ie is not None:
 
247
        # we have a parent ie already
 
248
        added = []
 
249
    else:
 
250
        # slower but does not need parent_ie
 
251
        if inv.has_filename(path):
 
252
            return []
 
253
        # add parent
 
254
        added = __add_one(tree, inv, None, dirname(path), 'directory', action)
 
255
        parent_id = inv.path2id(dirname(path))
 
256
        if parent_id is not None:
 
257
            parent_ie = inv[inv.path2id(dirname(path))]
 
258
        else:
 
259
            parent_ie = None
 
260
    action(inv, parent_ie, path, kind)
209
261
 
210
262
    return added + [path]