← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/add.py

[merge] jam-integration 1495

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