/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

Combine the ignore rules into a single regex rather than looping over them
to reduce the threshold where  N^2 behaviour occurs in operations like
status. (Jan Hudec, Robert Collins).

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/add.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
from trace import mutter, note
 
17
from os.path import dirname
 
18
 
 
19
import bzrlib.errors as errors
 
20
from bzrlib.inventory import InventoryEntry
 
21
from bzrlib.trace import mutter, note, warning
 
22
from bzrlib.errors import NotBranchError
 
23
import bzrlib.osutils
 
24
from bzrlib.workingtree import WorkingTree
18
25
 
19
26
def glob_expand_for_win32(file_list):
 
27
    if not file_list:
 
28
        return
20
29
    import glob
21
 
    
22
30
    expanded_file_list = []
23
31
    for possible_glob in file_list:
24
32
        glob_files = glob.glob(possible_glob)
31
39
            expanded_file_list += glob_files
32
40
    return expanded_file_list
33
41
 
34
 
def smart_add(file_list, verbose=True, recurse=True):
35
 
    """Add files to version, optionally recursing into directories.
36
42
 
37
 
    This is designed more towards DWIM for humans than API simplicity.
38
 
    For the specific behaviour see the help for cmd_add().
39
 
    """
40
 
    import os
 
43
def _prepare_file_list(file_list):
 
44
    """Prepare a file list for use by smart_add_*."""
41
45
    import sys
42
 
    from bzrlib.osutils import quotefn, kind_marker
43
 
    from bzrlib.errors import BadFileKindError, ForbiddenFileError
44
 
    import bzrlib.branch
45
 
    import bzrlib.osutils
46
 
 
47
46
    if sys.platform == 'win32':
48
47
        file_list = glob_expand_for_win32(file_list)
49
 
        
50
48
    if not file_list:
51
 
        file_list = ['.']
52
 
    
 
49
        file_list = [u'.']
 
50
    file_list = list(file_list)
 
51
    return file_list
 
52
 
 
53
 
 
54
def add_action_null(inv, path, kind):
 
55
    """Absorb add actions and do nothing."""
 
56
    pass
 
57
 
 
58
def add_action_print(inv, path, kind):
 
59
    """Print a line to stdout for each file that would be added."""
 
60
    print "added", bzrlib.osutils.quotefn(path)
 
61
 
 
62
def add_action_add(inv, path, kind):
 
63
    """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):
 
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):
 
75
    """Add files to version, optionally recursing into directories.
 
76
 
 
77
    This is designed more towards DWIM for humans than API simplicity.
 
78
    For the specific behaviour see the help for cmd_add().
 
79
 
 
80
    Returns the number of files added.
 
81
    """
 
82
    file_list = _prepare_file_list(file_list)
 
83
    tree = WorkingTree.open_containing(file_list[0])[0]
 
84
    return smart_add_tree(tree, file_list, recurse, action)
 
85
 
 
86
 
 
87
def smart_add_tree(tree, file_list, recurse=True, action=add_action_add):
 
88
    """Add files to version, optionally recursing into directories.
 
89
 
 
90
    This is designed more towards DWIM for humans than API simplicity.
 
91
    For the specific behaviour see the help for cmd_add().
 
92
 
 
93
    This calls reporter with each (path, kind, file_id) of added files.
 
94
 
 
95
    Returns the number of files added.
 
96
    """
 
97
    import os, errno
 
98
    from bzrlib.errors import BadFileKindError, ForbiddenFileError
 
99
    assert isinstance(recurse, bool)
 
100
 
 
101
    file_list = _prepare_file_list(file_list)
53
102
    user_list = file_list[:]
54
 
    assert not isinstance(file_list, basestring)
55
 
    b = bzrlib.branch.Branch(file_list[0], find_root=True)
56
 
    inv = b.read_working_inventory()
57
 
    tree = b.working_tree()
58
 
    count = 0
 
103
    inv = tree.read_working_inventory()
 
104
    added = []
 
105
    ignored = {}
 
106
    user_files = set(file_list)
59
107
 
60
108
    for f in file_list:
61
 
        rf = b.relpath(f)
62
 
        af = b.abspath(rf)
63
 
 
64
 
        kind = bzrlib.osutils.file_kind(af)
65
 
 
66
 
        if kind != 'file' and kind != 'directory':
 
109
        rf = tree.relpath(f)
 
110
        af = tree.abspath(rf)
 
111
 
 
112
        try:
 
113
            kind = bzrlib.osutils.file_kind(af)
 
114
        except OSError, e:
 
115
            if hasattr(e, 'errno') and e.errno == errno.ENOENT:
 
116
                raise errors.NoSuchFile(rf)
 
117
            raise
 
118
 
 
119
        if not InventoryEntry.versionable_kind(kind):
67
120
            if f in user_list:
68
121
                raise BadFileKindError("cannot add %s of type %s" % (f, kind))
69
122
            else:
70
 
                print "skipping %s (can't add file of kind '%s')" % (f, kind)
 
123
                warning("skipping %s (can't add file of kind '%s')", f, kind)
71
124
                continue
72
125
 
73
 
        mutter("smart add of %r, abs=%r" % (f, af))
74
 
        
75
 
        if bzrlib.branch.is_control_file(af):
 
126
        mutter("smart add of %r, abs=%r", f, af)
 
127
            
 
128
        # validate user parameters. Our recursive code avoids adding new files
 
129
        # that need such validation 
 
130
        if f in user_files and tree.is_control_filename(af):
76
131
            raise ForbiddenFileError('cannot add control file %s' % f)
77
 
            
 
132
 
78
133
        versioned = (inv.path2id(rf) != None)
79
134
 
 
135
        if kind == 'directory':
 
136
            try:
 
137
                sub_branch = WorkingTree.open(af)
 
138
                sub_tree = True
 
139
            except NotBranchError:
 
140
                sub_tree = False
 
141
            except errors.UnsupportedFormatError:
 
142
                sub_tree = True
 
143
        else:
 
144
            sub_tree = False
 
145
 
80
146
        if rf == '':
81
 
            mutter("branch root doesn't need to be added")
 
147
            mutter("tree root doesn't need to be added")
 
148
            sub_tree = False
82
149
        elif versioned:
83
 
            mutter("%r is already versioned" % f)
 
150
            mutter("%r is already versioned", f)
 
151
        elif sub_tree:
 
152
            mutter("%r is a bzr tree", f)
84
153
        else:
85
 
            file_id = bzrlib.branch.gen_file_id(rf)
86
 
            inv.add_path(rf, kind=kind, file_id=file_id)
87
 
            mutter("added %r kind %r file_id={%s}" % (rf, kind, file_id))
88
 
            count += 1 
89
 
 
90
 
            print 'added', quotefn(f)
91
 
 
92
 
        if kind == 'directory' and recurse:
 
154
            added.extend(__add_one(tree, inv, rf, kind, action))
 
155
 
 
156
        if kind == 'directory' and recurse and not sub_tree:
93
157
            for subf in os.listdir(af):
94
 
                subp = os.path.join(rf, subf)
95
 
                if subf == bzrlib.BZRDIR:
96
 
                    mutter("skip control directory %r" % subp)
97
 
                elif tree.is_ignored(subp):
98
 
                    mutter("skip ignored sub-file %r" % subp)
 
158
                subp = bzrlib.osutils.pathjoin(rf, subf)
 
159
                if tree.is_control_filename(subp):
 
160
                    mutter("skip control directory %r", subp)
99
161
                else:
100
 
                    mutter("queue to add sub-file %r" % subp)
101
 
                    file_list.append(b.abspath(subp))
102
 
 
103
 
    if count > 0:
104
 
        if verbose:
105
 
            note('added %d' % count)
106
 
        b._write_inventory(inv)
107
 
    else:
108
 
        print "nothing new to add"
109
 
        # should this return 1 to the shell?
 
162
                    ignore_glob = tree.is_ignored(subp)
 
163
                    if ignore_glob is not None:
 
164
                        mutter("skip ignored sub-file %r", subp)
 
165
                        if ignore_glob not in ignored:
 
166
                            ignored[ignore_glob] = []
 
167
                        ignored[ignore_glob].append(subp)
 
168
                    else:
 
169
                        mutter("queue to add sub-file %r", subp)
 
170
                        file_list.append(tree.abspath(subp))
 
171
 
 
172
    mutter('added %d entries', len(added))
 
173
    
 
174
    if len(added) > 0:
 
175
        tree._write_inventory(inv)
 
176
 
 
177
    return added, ignored
 
178
 
 
179
 
 
180
def __add_one(tree, inv, path, kind, action):
 
181
    """Add a file or directory, automatically add unversioned parents."""
 
182
 
 
183
    # Nothing to do if path is already versioned.
 
184
    # This is safe from infinite recursion because the tree root is
 
185
    # always versioned.
 
186
    if inv.path2id(path) != None:
 
187
        return []
 
188
 
 
189
    # add parent
 
190
    added = __add_one(tree, inv, dirname(path), 'directory', action)
 
191
    action(inv, path, kind)
 
192
 
 
193
    return added + [path]