← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/add.py

  • Committer: Martin Pool
  • Date: 2005-09-07 23:14:30 UTC
  • mto: (1092.2.12) (974.1.76) (1185.8.2)
  • mto: This revision was merged to the branch mainline in revision 1390.
  • Revision ID: mbp@sourcefrog.net-20050907231430-097abbaee94ad75b
- docstring fix from Magnus Therning

Show diffs side-by-side

added added

removed removed

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