/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/add.py

  • Committer: Robert Collins
  • Date: 2006-06-11 09:11:14 UTC
  • mto: (1767.2.2 integration)
  • mto: This revision was merged to the branch mainline in revision 1769.
  • Revision ID: robertc@robertcollins.net-20060611091114-141ab4165857931e
Remove spurious u cast from test_smart_add.py

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/add.py
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
import sys
 
18
from os.path import dirname
 
19
 
 
20
import bzrlib.errors as errors
 
21
from bzrlib.inventory import InventoryEntry
 
22
from bzrlib.trace import mutter, note, warning
 
23
from bzrlib.errors import NotBranchError
 
24
import bzrlib.osutils
 
25
from bzrlib.workingtree import WorkingTree
 
26
 
 
27
 
 
28
def glob_expand_for_win32(file_list):
 
29
    if not file_list:
 
30
        return
 
31
    import glob
 
32
    expanded_file_list = []
 
33
    for possible_glob in file_list:
 
34
        glob_files = glob.glob(possible_glob)
 
35
       
 
36
        if glob_files == []:
 
37
            # special case to let the normal code path handle
 
38
            # files that do not exists
 
39
            expanded_file_list.append(possible_glob)
 
40
        else:
 
41
            expanded_file_list += glob_files
 
42
    return expanded_file_list
 
43
 
 
44
 
 
45
def _prepare_file_list(file_list):
 
46
    """Prepare a file list for use by smart_add_*."""
 
47
    if sys.platform == 'win32':
 
48
        file_list = glob_expand_for_win32(file_list)
 
49
    if not file_list:
 
50
        file_list = [u'.']
 
51
    file_list = list(file_list)
 
52
    return file_list
 
53
 
 
54
 
 
55
class AddAction(object):
 
56
    """A class which defines what action to take when adding a file."""
 
57
 
 
58
    def __init__(self, to_file=None, should_print=None):
 
59
        self._to_file = to_file
 
60
        if to_file is None:
 
61
            self._to_file = sys.stdout
 
62
        self.should_print = False
 
63
        if should_print is not None:
 
64
            self.should_print = should_print
 
65
 
 
66
    def __call__(self, inv, parent_ie, path, kind):
 
67
        """Add path to inventory.
 
68
 
 
69
        The default action does nothing.
 
70
 
 
71
        :param inv: The inventory we are working with.
 
72
        :param path: The FastPath being added
 
73
        :param kind: The kind of the object being added.
 
74
        """
 
75
        if not self.should_print:
 
76
            return
 
77
        self._to_file.write('added ')
 
78
        self._to_file.write(bzrlib.osutils.quotefn(path.raw_path))
 
79
        self._to_file.write('\n')
 
80
 
 
81
 
 
82
# TODO: jam 20050105 These could be used for compatibility
 
83
#       however, they bind against the current stdout, not the
 
84
#       one which exists at the time they are called, so they
 
85
#       don't work for the test suite.
 
86
# deprecated
 
87
add_action_add = AddAction()
 
88
add_action_null = add_action_add
 
89
add_action_add_and_print = AddAction(should_print=True)
 
90
add_action_print = add_action_add_and_print
 
91
 
 
92
 
 
93
def smart_add(file_list, recurse=True, action=None, save=True):
 
94
    """Add files to version, optionally recursing into directories.
 
95
 
 
96
    This is designed more towards DWIM for humans than API simplicity.
 
97
    For the specific behaviour see the help for cmd_add().
 
98
 
 
99
    Returns the number of files added.
 
100
    Please see smart_add_tree for more detail.
 
101
    """
 
102
    file_list = _prepare_file_list(file_list)
 
103
    tree = WorkingTree.open_containing(file_list[0])[0]
 
104
    return smart_add_tree(tree, file_list, recurse, action=action)
 
105
 
 
106
 
 
107
class FastPath(object):
 
108
    """A path object with fast accessors for things like basename."""
 
109
 
 
110
    __slots__ = ['raw_path', 'base_path']
 
111
 
 
112
    def __init__(self, path, base_path=None):
 
113
        """Construct a FastPath from path."""
 
114
        if base_path is None:
 
115
            self.base_path = bzrlib.osutils.basename(path)
 
116
        else:
 
117
            self.base_path = base_path
 
118
        self.raw_path = path
 
119
 
 
120
 
 
121
def smart_add_tree(tree, file_list, recurse=True, action=None, save=True):
 
122
    """Add files to version, optionally recursing into directories.
 
123
 
 
124
    This is designed more towards DWIM for humans than API simplicity.
 
125
    For the specific behaviour see the help for cmd_add().
 
126
 
 
127
    This calls reporter with each (path, kind, file_id) of added files.
 
128
 
 
129
    Returns the number of files added.
 
130
    
 
131
    :param save: Save the inventory after completing the adds. If False this
 
132
    provides dry-run functionality by doing the add and not saving the
 
133
    inventory.  Note that the modified inventory is left in place, allowing 
 
134
    further dry-run tasks to take place. To restore the original inventory
 
135
    call tree.read_working_inventory().
 
136
    """
 
137
    import os, errno
 
138
    from bzrlib.errors import BadFileKindError, ForbiddenFileError
 
139
    assert isinstance(recurse, bool)
 
140
    if action is None:
 
141
        action = AddAction()
 
142
    
 
143
    prepared_list = _prepare_file_list(file_list)
 
144
    mutter("smart add of %r, originally %r", prepared_list, file_list)
 
145
    inv = tree.read_working_inventory()
 
146
    added = []
 
147
    ignored = {}
 
148
    dirs_to_add = []
 
149
    user_dirs = set()
 
150
 
 
151
    # validate user file paths and convert all paths to tree 
 
152
    # relative : its cheaper to make a tree relative path an abspath
 
153
    # than to convert an abspath to tree relative.
 
154
    for filepath in prepared_list:
 
155
        rf = FastPath(tree.relpath(filepath))
 
156
        # validate user parameters. Our recursive code avoids adding new files
 
157
        # that need such validation 
 
158
        if tree.is_control_filename(rf.raw_path):
 
159
            raise ForbiddenFileError('cannot add control file %s' % filepath)
 
160
        
 
161
        abspath = tree.abspath(rf.raw_path)
 
162
        kind = bzrlib.osutils.file_kind(abspath)
 
163
        if kind == 'directory':
 
164
            # schedule the dir for scanning
 
165
            user_dirs.add(rf.raw_path)
 
166
        else:
 
167
            if not InventoryEntry.versionable_kind(kind):
 
168
                raise BadFileKindError("cannot add %s of type %s" % (abspath, kind))
 
169
        # ensure the named path is added, so that ignore rules in the later directory
 
170
        # walk dont skip it.
 
171
        # we dont have a parent ie known yet.: use the relatively slower inventory 
 
172
        # probing method
 
173
        versioned = inv.has_filename(rf.raw_path)
 
174
        if versioned:
 
175
            continue
 
176
        added.extend(__add_one_and_parent(tree, inv, None, rf, kind, action))
 
177
 
 
178
    if not recurse:
 
179
        # no need to walk any directories at all.
 
180
        if len(added) > 0 and save:
 
181
            tree._write_inventory(inv)
 
182
        return added, ignored
 
183
 
 
184
    # only walk the minimal parents needed: we have user_dirs to override
 
185
    # ignores.
 
186
    prev_dir = None
 
187
    for path in sorted(user_dirs):
 
188
        if (prev_dir is None or not
 
189
            bzrlib.osutils.is_inside_or_parent_of_any([prev_dir], path)):
 
190
            dirs_to_add.append((rf, None))
 
191
        prev_dir = path
 
192
 
 
193
    # this will eventually be *just* directories, right now it starts off with 
 
194
    # just directories.
 
195
    for directory, parent_ie in dirs_to_add:
 
196
        # directory is tree-relative
 
197
        abspath = tree.abspath(directory.raw_path)
 
198
 
 
199
        # get the contents of this directory.
 
200
 
 
201
        # find the kind of the path being added.
 
202
        kind = bzrlib.osutils.file_kind(abspath)
 
203
 
 
204
        if not InventoryEntry.versionable_kind(kind):
 
205
            warning("skipping %s (can't add file of kind '%s')", abspath, kind)
 
206
            continue
 
207
 
 
208
        if parent_ie is not None:
 
209
            versioned = directory.base_path in parent_ie.children
 
210
        else:
 
211
            # without the parent ie, use the relatively slower inventory 
 
212
            # probing method
 
213
            versioned = inv.has_filename(directory.raw_path)
 
214
 
 
215
        if kind == 'directory':
 
216
            try:
 
217
                sub_branch = bzrlib.bzrdir.BzrDir.open(abspath)
 
218
                sub_tree = True
 
219
            except NotBranchError:
 
220
                sub_tree = False
 
221
            except errors.UnsupportedFormatError:
 
222
                sub_tree = True
 
223
        else:
 
224
            sub_tree = False
 
225
 
 
226
        if directory.raw_path == '':
 
227
            # mutter("tree root doesn't need to be added")
 
228
            sub_tree = False
 
229
        elif versioned:
 
230
            pass
 
231
            # mutter("%r is already versioned", abspath)
 
232
        elif sub_tree:
 
233
            mutter("%r is a nested bzr tree", abspath)
 
234
        else:
 
235
            __add_one(tree, inv, parent_ie, directory, kind, action)
 
236
            added.append(directory.raw_path)
 
237
 
 
238
        if kind == 'directory' and not sub_tree:
 
239
            if parent_ie is not None:
 
240
                # must be present:
 
241
                this_ie = parent_ie.children[directory.base_path]
 
242
            else:
 
243
                # without the parent ie, use the relatively slower inventory 
 
244
                # probing method
 
245
                this_id = inv.path2id(directory.raw_path)
 
246
                if this_id is None:
 
247
                    this_ie = None
 
248
                else:
 
249
                    this_ie = inv[this_id]
 
250
 
 
251
            for subf in os.listdir(abspath):
 
252
                # here we could use TreeDirectory rather than 
 
253
                # string concatenation.
 
254
                subp = bzrlib.osutils.pathjoin(directory.raw_path, subf)
 
255
                # TODO: is_control_filename is very slow. Make it faster. 
 
256
                # TreeDirectory.is_control_filename could also make this 
 
257
                # faster - its impossible for a non root dir to have a 
 
258
                # control file.
 
259
                if tree.is_control_filename(subp):
 
260
                    mutter("skip control directory %r", subp)
 
261
                elif subf in this_ie.children:
 
262
                    # recurse into this already versioned subdir.
 
263
                    dirs_to_add.append((FastPath(subp, subf), this_ie))
 
264
                else:
 
265
                    # user selection overrides ignoes
 
266
                    # ignore while selecting files - if we globbed in the
 
267
                    # outer loop we would ignore user files.
 
268
                    ignore_glob = tree.is_ignored(subp)
 
269
                    if ignore_glob is not None:
 
270
                        # mutter("skip ignored sub-file %r", subp)
 
271
                        if ignore_glob not in ignored:
 
272
                            ignored[ignore_glob] = []
 
273
                        ignored[ignore_glob].append(subp)
 
274
                    else:
 
275
                        #mutter("queue to add sub-file %r", subp)
 
276
                        dirs_to_add.append((FastPath(subp, subf), this_ie))
 
277
 
 
278
    if len(added) > 0 and save:
 
279
        tree._write_inventory(inv)
 
280
    return added, ignored
 
281
 
 
282
 
 
283
def __add_one_and_parent(tree, inv, parent_ie, path, kind, action):
 
284
    """Add a new entry to the inventory and automatically add unversioned parents.
 
285
 
 
286
    :param inv: Inventory which will receive the new entry.
 
287
    :param parent_ie: Parent inventory entry if known, or None.  If
 
288
    None, the parent is looked up by name and used if present, otherwise
 
289
    it is recursively added.
 
290
    :param kind: Kind of new entry (file, directory, etc)
 
291
    :param action: callback(inv, parent_ie, path, kind); return ignored.
 
292
    :returns: A list of paths which have been added.
 
293
    """
 
294
    # Nothing to do if path is already versioned.
 
295
    # This is safe from infinite recursion because the tree root is
 
296
    # always versioned.
 
297
    if parent_ie is not None:
 
298
        # we have a parent ie already
 
299
        added = []
 
300
    else:
 
301
        # slower but does not need parent_ie
 
302
        if inv.has_filename(path.raw_path):
 
303
            return []
 
304
        # its really not there : add the parent
 
305
        # note that the dirname use leads to some extra str copying etc but as
 
306
        # there are a limited number of dirs we can be nested under, it should
 
307
        # generally find it very fast and not recurse after that.
 
308
        added = __add_one_and_parent(tree, inv, None, FastPath(dirname(path.raw_path)), 'directory', action)
 
309
        parent_id = inv.path2id(dirname(path.raw_path))
 
310
        if parent_id is None:
 
311
            parent_ie = inv[inv.path2id(dirname(path.raw_path))]
 
312
        else:
 
313
            parent_ie = inv[parent_id]
 
314
    __add_one(tree, inv, parent_ie, path, kind, action)
 
315
    return added + [path.raw_path]
 
316
 
 
317
 
 
318
def __add_one(tree, inv, parent_ie, path, kind, action):
 
319
    """Add a new entry to the inventory.
 
320
 
 
321
    :param inv: Inventory which will receive the new entry.
 
322
    :param parent_ie: Parent inventory entry.
 
323
    :param kind: Kind of new entry (file, directory, etc)
 
324
    :param action: callback(inv, parent_ie, path, kind); return ignored.
 
325
    :returns: None
 
326
    """
 
327
    action(inv, parent_ie, path, kind)
 
328
    entry = bzrlib.inventory.make_entry(kind, path.base_path, parent_ie.file_id)
 
329
    inv.add(entry)