/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

Review comments for gen_file_id changes.

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
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
 
25
 
 
26
def glob_expand_for_win32(file_list):
 
27
    if not file_list:
 
28
        return
 
29
    import glob
 
30
    expanded_file_list = []
 
31
    for possible_glob in file_list:
 
32
        glob_files = glob.glob(possible_glob)
 
33
       
 
34
        if glob_files == []:
 
35
            # special case to let the normal code path handle
 
36
            # files that do not exists
 
37
            expanded_file_list.append(possible_glob)
 
38
        else:
 
39
            expanded_file_list += glob_files
 
40
    return expanded_file_list
 
41
 
 
42
 
 
43
def _prepare_file_list(file_list):
 
44
    """Prepare a file list for use by smart_add_*."""
 
45
    import sys
 
46
    if sys.platform == 'win32':
 
47
        file_list = glob_expand_for_win32(file_list)
 
48
    if not file_list:
 
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)
 
102
    user_list = file_list[:]
 
103
    inv = tree.read_working_inventory()
 
104
    added = []
 
105
    ignored = {}
 
106
    user_files = set(file_list)
 
107
 
 
108
    for f in file_list:
 
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):
 
120
            if f in user_list:
 
121
                raise BadFileKindError("cannot add %s of type %s" % (f, kind))
 
122
            else:
 
123
                warning("skipping %s (can't add file of kind '%s')", f, kind)
 
124
                continue
 
125
 
 
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):
 
131
            raise ForbiddenFileError('cannot add control file %s' % f)
 
132
 
 
133
        versioned = (inv.path2id(rf) != None)
 
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
 
 
146
        if rf == '':
 
147
            mutter("tree root doesn't need to be added")
 
148
            sub_tree = False
 
149
        elif versioned:
 
150
            mutter("%r is already versioned", f)
 
151
        elif sub_tree:
 
152
            mutter("%r is a bzr tree", f)
 
153
        else:
 
154
            added.extend(__add_one(tree, inv, rf, kind, action))
 
155
 
 
156
        if kind == 'directory' and recurse and not sub_tree:
 
157
            for subf in os.listdir(af):
 
158
                subp = bzrlib.osutils.pathjoin(rf, subf)
 
159
                if tree.is_control_filename(subp):
 
160
                    mutter("skip control directory %r", subp)
 
161
                else:
 
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]