/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-10 16:36:40 UTC
  • mto: (1767.2.2 integration)
  • mto: This revision was merged to the branch mainline in revision 1769.
  • Revision ID: robertc@robertcollins.net-20060610163640-6e698ef82c39d3cf
Steps towards a nicer smart add - unwind the conditional add logic - having parents not in the inventory was overly complicating the rest of the code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/add.py
55
55
class AddAction(object):
56
56
    """A class which defines what action to take when adding a file."""
57
57
 
58
 
    def __init__(self, to_file=None, should_add=None, should_print=None):
 
58
    def __init__(self, to_file=None, should_print=None):
59
59
        self._to_file = to_file
60
60
        if to_file is None:
61
61
            self._to_file = sys.stdout
62
 
        self.should_add = False
63
 
        if should_add is not None:
64
 
            self.should_add = should_add
65
62
        self.should_print = False
66
63
        if should_print is not None:
67
64
            self.should_print = should_print
75
72
        :param path: The FastPath being added
76
73
        :param kind: The kind of the object being added.
77
74
        """
78
 
        if self.should_add:
79
 
            self._add_to_inv(inv, parent_ie, path, kind)
80
 
        if self.should_print:
81
 
            self._print(inv, parent_ie, path, kind)
82
 
 
83
 
    def _print(self, inv, parent_ie, path, kind):
84
 
        """Print a line to self._to_file for each file that would be added."""
 
75
        if not self.should_print:
 
76
            return
85
77
        self._to_file.write('added ')
86
78
        self._to_file.write(bzrlib.osutils.quotefn(path.raw_path))
87
79
        self._to_file.write('\n')
88
80
 
89
 
    def _add_to_inv(self, inv, parent_ie, path, kind):
90
 
        """Add each file to the given inventory. Produce no output."""
91
 
        if parent_ie is not None:
92
 
            entry = bzrlib.inventory.make_entry(
93
 
                kind, bzrlib.osutils.basename(path.raw_path),  parent_ie.file_id)
94
 
            inv.add(entry)
95
 
        else:
96
 
            entry = inv.add_path(path.raw_path, kind=kind)
97
 
        # mutter("added %r kind %r file_id={%s}", path, kind, entry.file_id)
98
 
 
99
81
 
100
82
# TODO: jam 20050105 These could be used for compatibility
101
83
#       however, they bind against the current stdout, not the
102
84
#       one which exists at the time they are called, so they
103
85
#       don't work for the test suite.
104
86
# deprecated
105
 
add_action_null = AddAction()
106
 
add_action_add = AddAction(should_add=True)
107
 
add_action_print = AddAction(should_print=True)
108
 
add_action_add_and_print = AddAction(should_add=True, should_print=True)
109
 
 
110
 
 
111
 
def smart_add(file_list, recurse=True, action=None):
 
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):
112
94
    """Add files to version, optionally recursing into directories.
113
95
 
114
96
    This is designed more towards DWIM for humans than API simplicity.
115
97
    For the specific behaviour see the help for cmd_add().
116
98
 
117
99
    Returns the number of files added.
 
100
    Please see smart_add_tree for more detail.
118
101
    """
119
102
    file_list = _prepare_file_list(file_list)
120
103
    tree = WorkingTree.open_containing(file_list[0])[0]
135
118
        self.raw_path = path
136
119
 
137
120
 
138
 
def smart_add_tree(tree, file_list, recurse=True, action=None):
 
121
def smart_add_tree(tree, file_list, recurse=True, action=None, save=True):
139
122
    """Add files to version, optionally recursing into directories.
140
123
 
141
124
    This is designed more towards DWIM for humans than API simplicity.
144
127
    This calls reporter with each (path, kind, file_id) of added files.
145
128
 
146
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().
147
136
    """
148
137
    import os, errno
149
138
    from bzrlib.errors import BadFileKindError, ForbiddenFileError
150
139
    assert isinstance(recurse, bool)
151
140
    if action is None:
152
 
        action = AddAction(should_add=True)
 
141
        action = AddAction()
153
142
    
154
143
    prepared_list = _prepare_file_list(file_list)
155
144
    mutter("smart add of %r, originally %r", prepared_list, file_list)
172
161
        abspath = tree.abspath(rf.raw_path)
173
162
        kind = bzrlib.osutils.file_kind(abspath)
174
163
        if kind == 'directory':
175
 
            # schedule the dir for later
 
164
            # schedule the dir for scanning
176
165
            user_dirs.add(rf.raw_path)
177
166
        else:
178
167
            if not InventoryEntry.versionable_kind(kind):
179
168
                raise BadFileKindError("cannot add %s of type %s" % (abspath, kind))
180
 
            # we dont have a parent ie known yet.: use the relatively slower inventory 
181
 
            # probing method
182
 
            versioned = inv.has_filename(rf.raw_path)
183
 
            if versioned:
184
 
                continue
185
 
            added.extend(__add_one(tree, inv, None, rf, kind, action))
 
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(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
186
183
 
187
184
    # only walk the minimal parents needed: we have user_dirs to override
188
185
    # ignores.
235
232
        else:
236
233
            added.extend(__add_one(tree, inv, parent_ie, directory, kind, action))
237
234
 
238
 
        if kind == 'directory' and recurse and not sub_tree:
239
 
            try:
240
 
                if parent_ie is not None:
241
 
                    # must be present:
242
 
                    this_ie = parent_ie.children[directory.base_path]
 
235
        if kind == 'directory' and not sub_tree:
 
236
            if parent_ie is not None:
 
237
                # must be present:
 
238
                this_ie = parent_ie.children[directory.base_path]
 
239
            else:
 
240
                # without the parent ie, use the relatively slower inventory 
 
241
                # probing method
 
242
                this_id = inv.path2id(directory.raw_path)
 
243
                if this_id is None:
 
244
                    this_ie = None
243
245
                else:
244
 
                    # without the parent ie, use the relatively slower inventory 
245
 
                    # probing method
246
 
                    this_id = inv.path2id(directory.raw_path)
247
 
                    if this_id is None:
248
 
                        this_ie = None
249
 
                    else:
250
 
                        this_ie = inv[this_id]
251
 
            except KeyError:
252
 
                this_ie = None
 
246
                    this_ie = inv[this_id]
253
247
 
254
248
            for subf in os.listdir(abspath):
255
249
                # here we could use TreeDirectory rather than 
261
255
                # control file.
262
256
                if tree.is_control_filename(subp):
263
257
                    mutter("skip control directory %r", subp)
 
258
                elif subf in this_ie.children:
 
259
                    # recurse into this already versioned subdir.
 
260
                    dirs_to_add.append((FastPath(subp, subf), this_ie))
264
261
                else:
265
262
                    # user selection overrides ignoes
266
 
                    if subp in user_dirs:
267
 
                        dirs_to_add.append((FastPath(subp, subf), this_ie))
268
 
                        continue
269
263
                    # ignore while selecting files - if we globbed in the
270
264
                    # outer loop we would ignore user files.
271
265
                    ignore_glob = tree.is_ignored(subp)
278
272
                        #mutter("queue to add sub-file %r", subp)
279
273
                        dirs_to_add.append((FastPath(subp, subf), this_ie))
280
274
 
281
 
    if len(added) > 0:
 
275
    if len(added) > 0 and save:
282
276
        tree._write_inventory(inv)
283
277
    return added, ignored
284
278
 
313
307
        # generally find it very fast and not recurse after that.
314
308
        added = __add_one(tree, inv, None, FastPath(dirname(path.raw_path)), 'directory', action)
315
309
        parent_id = inv.path2id(dirname(path.raw_path))
316
 
        if parent_id is not None:
 
310
        if parent_id is None:
317
311
            parent_ie = inv[inv.path2id(dirname(path.raw_path))]
318
312
        else:
319
 
            parent_ie = None
 
313
            parent_ie = inv[parent_id]
320
314
    action(inv, parent_ie, path, kind)
 
315
    #if parent_ie is not None:
 
316
    entry = bzrlib.inventory.make_entry(
 
317
        kind, bzrlib.osutils.basename(path.raw_path),  parent_ie.file_id)
 
318
    inv.add(entry)
 
319
    #else:
 
320
    #    entry = inv.add_path(path.raw_path, kind=kind)
 
321
 
321
322
 
322
323
    return added + [path.raw_path]