← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/add.py

  • Committer: abentley
  • Date: 2005-10-14 03:50:50 UTC
  • mto: (1185.25.1)
  • mto: This revision was merged to the branch mainline in revision 1460.
  • Revision ID: abentley@lappy-20051014035050-d779472ccb599a51
semi-broke merge

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