~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/add.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-05-22 14:53:12 UTC
  • mfrom: (1707.3.30 ftp-server)
  • Revision ID: pqm@pqm.ubuntu.com-20060522145312-94c3c934d7cbd9ff
(jam) use medusa as an ftp-server provider, fix FtpTransport

Show diffs side-by-side

added added

removed removed

Lines of Context:
20
20
from bzrlib.inventory import InventoryEntry
21
21
from bzrlib.trace import mutter, note, warning
22
22
from bzrlib.errors import NotBranchError
23
 
from bzrlib.workingtree import is_control_file
24
23
import bzrlib.osutils
25
24
from bzrlib.workingtree import WorkingTree
26
25
 
65
64
    entry = inv.add_path(path, kind=kind)
66
65
    mutter("added %r kind %r file_id={%s}" % (path, kind, entry.file_id))
67
66
 
 
67
 
68
68
def add_action_add_and_print(inv, path, kind):
69
69
    """Add each file to the given inventory, and print a line to stdout."""
70
70
    add_action_add(inv, path, kind)
83
83
    tree = WorkingTree.open_containing(file_list[0])[0]
84
84
    return smart_add_tree(tree, file_list, recurse, action)
85
85
 
 
86
 
86
87
def smart_add_tree(tree, file_list, recurse=True, action=add_action_add):
87
88
    """Add files to version, optionally recursing into directories.
88
89
 
96
97
    import os, errno
97
98
    from bzrlib.errors import BadFileKindError, ForbiddenFileError
98
99
    assert isinstance(recurse, bool)
99
 
 
 
100
    
 
101
    orig_list = file_list
100
102
    file_list = _prepare_file_list(file_list)
101
 
    user_list = file_list[:]
 
103
    mutter("smart add of %r, originally %r", file_list, orig_list)
102
104
    inv = tree.read_working_inventory()
103
105
    added = []
104
106
    ignored = {}
105
 
 
106
 
    for f in file_list:
107
 
        rf = tree.relpath(f)
108
 
        af = tree.abspath(rf)
109
 
 
 
107
    user_files = set(file_list)
 
108
 
 
109
    for filepath in file_list:
 
110
        # convert a random abs or cwd-relative path to tree relative.
 
111
        rf = tree.relpath(filepath)
 
112
 
 
113
        # validate user parameters. Our recursive code avoids adding new files
 
114
        # that need such validation 
 
115
        if filepath in user_files and tree.is_control_filename(rf):
 
116
            raise ForbiddenFileError('cannot add control file %s' % filepath)
 
117
 
 
118
        # find the kind of the path being added. This is not
 
119
        # currently determined when we list directories 
 
120
        # recursively, but in theory we can determine while 
 
121
        # doing the directory listing on *some* platformans.
 
122
        # TODO: a safe, portable, clean interface which will 
 
123
        # be faster than os.listdir() + stat. Specifically,
 
124
        # readdir - dirent.d_type supplies the file type when
 
125
        # it is defined. (Apparently Mac OSX has the field but
 
126
        # does not fill it in ?!) Robert C, Martin P.
110
127
        try:
111
 
            kind = bzrlib.osutils.file_kind(af)
 
128
            kind = bzrlib.osutils.file_kind(filepath)
112
129
        except OSError, e:
113
130
            if hasattr(e, 'errno') and e.errno == errno.ENOENT:
114
 
                raise errors.NoSuchFile(rf)
 
131
                raise errors.NoSuchFile(filepath)
115
132
            raise
116
133
 
 
134
        # we need to call this to determine the inventory kind to create.
117
135
        if not InventoryEntry.versionable_kind(kind):
118
 
            if f in user_list:
119
 
                raise BadFileKindError("cannot add %s of type %s" % (f, kind))
 
136
            if filepath in user_files:
 
137
                raise BadFileKindError("cannot add %s of type %s" % (filepath, kind))
120
138
            else:
121
 
                warning("skipping %s (can't add file of kind '%s')", f, kind)
 
139
                warning("skipping %s (can't add file of kind '%s')", filepath, kind)
122
140
                continue
123
141
 
124
 
        mutter("smart add of %r, abs=%r", f, af)
125
 
        
126
 
        if tree.is_control_filename(af):
127
 
            raise ForbiddenFileError('cannot add control file %s' % f)
128
 
            
129
 
        versioned = (inv.path2id(rf) != None)
 
142
        # TODO make has_filename faster or provide a better api for accessing/determining 
 
143
        # this status. perhaps off the inventory directory object.
 
144
        versioned = inv.has_filename(rf)
130
145
 
131
146
        if kind == 'directory':
132
147
            try:
133
 
                sub_branch = WorkingTree.open(af)
 
148
                sub_branch = bzrlib.bzrdir.BzrDir.open(filepath)
134
149
                sub_tree = True
135
150
            except NotBranchError:
136
151
                sub_tree = False
140
155
            sub_tree = False
141
156
 
142
157
        if rf == '':
143
 
            mutter("tree root doesn't need to be added")
 
158
            # mutter("tree root doesn't need to be added")
144
159
            sub_tree = False
145
160
        elif versioned:
146
 
            mutter("%r is already versioned", f)
 
161
            pass
 
162
            # mutter("%r is already versioned", filepath)
147
163
        elif sub_tree:
148
 
            mutter("%r is a bzr tree", f)
 
164
            mutter("%r is a nested bzr tree", filepath)
149
165
        else:
150
166
            added.extend(__add_one(tree, inv, rf, kind, action))
151
167
 
152
168
        if kind == 'directory' and recurse and not sub_tree:
153
 
            for subf in os.listdir(af):
 
169
            for subf in os.listdir(filepath):
 
170
                # here we could use TreeDirectory rather than 
 
171
                # string concatenation.
154
172
                subp = bzrlib.osutils.pathjoin(rf, subf)
 
173
                # TODO: is_control_filename is very slow. Make it faster. 
 
174
                # TreeDirectory.is_control_filename could also make this 
 
175
                # faster - its impossible for a non root dir to have a 
 
176
                # control file.
155
177
                if tree.is_control_filename(subp):
156
178
                    mutter("skip control directory %r", subp)
157
179
                else:
 
180
                    # ignore while selecting files - if we globbed in the
 
181
                    # outer loop we would ignore user files.
158
182
                    ignore_glob = tree.is_ignored(subp)
159
183
                    if ignore_glob is not None:
160
 
                        mutter("skip ignored sub-file %r", subp)
 
184
                        # mutter("skip ignored sub-file %r", subp)
161
185
                        if ignore_glob not in ignored:
162
186
                            ignored[ignore_glob] = []
163
187
                        ignored[ignore_glob].append(subp)
164
188
                    else:
165
 
                        mutter("queue to add sub-file %r", subp)
 
189
                        #mutter("queue to add sub-file %r", subp)
166
190
                        file_list.append(tree.abspath(subp))
167
191
 
168
 
 
169
 
    mutter('added %d entries', len(added))
170
 
    
171
192
    if len(added) > 0:
172
193
        tree._write_inventory(inv)
173
 
 
174
194
    return added, ignored
175
195
 
 
196
 
176
197
def __add_one(tree, inv, path, kind, action):
177
198
    """Add a file or directory, automatically add unversioned parents."""
178
199