← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/add.py

 * bzr add now lists how many files were ignored per glob.  add --verbose
   lists the specific files.  (Aaron Bentley)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/add.py
41
41
    return expanded_file_list
42
42
 
43
43
 
44
 
def add_reporter_null(path, kind, entry):
45
 
    """Absorb add reports and do nothing."""
46
 
    pass
47
 
 
48
 
 
49
 
def add_reporter_print(path, kind, entry):
50
 
    """Print a line to stdout for each file that's added."""
51
 
    print "added", bzrlib.osutils.quotefn(path)
52
 
 
53
 
 
54
44
def _prepare_file_list(file_list):
55
45
    """Prepare a file list for use by smart_add_*."""
56
46
    import sys
57
47
    if sys.platform == 'win32':
58
48
        file_list = glob_expand_for_win32(file_list)
59
49
    if not file_list:
60
 
        file_list = ['.']
 
50
        file_list = [u'.']
61
51
    file_list = list(file_list)
62
52
    return file_list
63
53
 
64
54
 
65
 
def smart_add(file_list, recurse=True, reporter=add_reporter_null):
 
55
def add_action_null(inv, path, kind):
 
56
    """Absorb add actions and do nothing."""
 
57
    pass
 
58
 
 
59
def add_action_print(inv, path, kind):
 
60
    """Print a line to stdout for each file that would be added."""
 
61
    print "added", bzrlib.osutils.quotefn(path)
 
62
 
 
63
def add_action_add(inv, path, kind):
 
64
    """Add each file to the given inventory. Produce no output."""
 
65
    entry = inv.add_path(path, kind=kind)
 
66
    mutter("added %r kind %r file_id={%s}" % (path, kind, entry.file_id))
 
67
 
 
68
def add_action_add_and_print(inv, path, kind):
 
69
    """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)
 
72
 
 
73
 
 
74
def smart_add(file_list, recurse=True, action=add_action_add):
66
75
    """Add files to version, optionally recursing into directories.
67
76
 
68
77
    This is designed more towards DWIM for humans than API simplicity.
72
81
    """
73
82
    file_list = _prepare_file_list(file_list)
74
83
    tree = WorkingTree.open_containing(file_list[0])[0]
75
 
    return smart_add_tree(tree, file_list, recurse, reporter)
 
84
    return smart_add_tree(tree, file_list, recurse, action)
76
85
 
77
 
        
78
 
def smart_add_tree(tree, file_list, recurse=True, reporter=add_reporter_null):
 
86
def smart_add_tree(tree, file_list, recurse=True, action=add_action_add):
79
87
    """Add files to version, optionally recursing into directories.
80
88
 
81
89
    This is designed more towards DWIM for humans than API simplicity.
85
93
 
86
94
    Returns the number of files added.
87
95
    """
88
 
    import os
 
96
    import os, errno
89
97
    from bzrlib.errors import BadFileKindError, ForbiddenFileError
90
98
    assert isinstance(recurse, bool)
91
99
 
92
100
    file_list = _prepare_file_list(file_list)
93
101
    user_list = file_list[:]
94
102
    inv = tree.read_working_inventory()
95
 
    count = 0
 
103
    added = []
 
104
    ignored = {}
96
105
 
97
106
    for f in file_list:
98
107
        rf = tree.relpath(f)
99
108
        af = tree.abspath(rf)
100
109
 
101
 
        kind = bzrlib.osutils.file_kind(af)
 
110
        try:
 
111
            kind = bzrlib.osutils.file_kind(af)
 
112
        except OSError, e:
 
113
            if hasattr(e, 'errno') and e.errno == errno.ENOENT:
 
114
                raise errors.NoSuchFile(rf)
 
115
            raise
102
116
 
103
117
        if not InventoryEntry.versionable_kind(kind):
104
118
            if f in user_list:
133
147
        elif sub_tree:
134
148
            mutter("%r is a bzr tree", f)
135
149
        else:
136
 
            count += __add_one(tree, inv, rf, kind, reporter)
 
150
            added.extend(__add_one(tree, inv, rf, kind, action))
137
151
 
138
152
        if kind == 'directory' and recurse and not sub_tree:
139
153
            for subf in os.listdir(af):
140
154
                subp = os.path.join(rf, subf)
141
155
                if subf == bzrlib.BZRDIR:
142
156
                    mutter("skip control directory %r", subp)
143
 
                elif tree.is_ignored(subp):
144
 
                    mutter("skip ignored sub-file %r", subp)
145
157
                else:
146
 
                    mutter("queue to add sub-file %r", subp)
147
 
                    file_list.append(tree.abspath(subp))
148
 
 
149
 
 
150
 
    mutter('added %d entries', count)
 
158
                    ignore_glob = tree.is_ignored(subp)
 
159
                    if ignore_glob is not None:
 
160
                        mutter("skip ignored sub-file %r", subp)
 
161
                        if ignore_glob not in ignored:
 
162
                            ignored[ignore_glob] = []
 
163
                        ignored[ignore_glob].append(subp)
 
164
                    else:
 
165
                        mutter("queue to add sub-file %r", subp)
 
166
                        file_list.append(tree.abspath(subp))
 
167
 
 
168
 
 
169
    mutter('added %d entries', len(added))
151
170
    
152
 
    if count > 0:
 
171
    if len(added) > 0:
153
172
        tree._write_inventory(inv)
154
173
 
155
 
    return count
 
174
    return added, ignored
156
175
 
157
 
def __add_one(tree, inv, path, kind, reporter):
 
176
def __add_one(tree, inv, path, kind, action):
158
177
    """Add a file or directory, automatically add unversioned parents."""
159
178
 
160
179
    # Nothing to do if path is already versioned.
161
180
    # This is safe from infinite recursion because the tree root is
162
181
    # always versioned.
163
182
    if inv.path2id(path) != None:
164
 
        return 0
 
183
        return []
165
184
 
166
185
    # add parent
167
 
    count = __add_one(tree, inv, dirname(path), 'directory', reporter)
168
 
 
169
 
    entry = inv.add_path(path, kind=kind)
170
 
    mutter("added %r kind %r file_id={%s}", path, kind, entry.file_id)
171
 
    reporter(path, kind, entry)
172
 
 
173
 
    return count + 1
 
186
    added = __add_one(tree, inv, dirname(path), 'directory', action)
 
187
    action(inv, path, kind)
 
188
 
 
189
    return added + [path]