~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/add.py

  • Committer: Robert Collins
  • Date: 2005-10-08 00:32:39 UTC
  • mfrom: (1185.13.4)
  • mto: This revision was merged to the branch mainline in revision 1422.
  • Revision ID: robertc@robertcollins.net-20051008003239-b4e2f1ad62bbe3f6
merge in reweave support

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