← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/add.py

  • Committer: Olaf Conradi
  • Date: 2006-03-28 23:30:02 UTC
  • mto: (1661.1.1 bzr.mbp.remember)
  • mto: This revision was merged to the branch mainline in revision 1663.
  • Revision ID: olaf@conradi.org-20060328233002-f6262df0e19c1963
Added testcases for using pull with --remember. Moved remember code to
beginning of cmd_pull. This remembers the location in case of a failure
during pull.

Show diffs side-by-side

added added

removed removed

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