/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

  • Committer: Robert Collins
  • Date: 2005-12-15 03:21:11 UTC
  • mfrom: (1185.56.2 fixes)
  • Revision ID: robertc@robertcollins.net-20051215032111-e68d5e6ffbd4b574
* Raise NoSuchFile when someone tries to add a non-existant file.
  (Michael Ellerman)

* Simplify handling of DivergedBranches in cmd_pull().
  (Michael Ellerman)

Show diffs side-by-side

added added

removed removed

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