~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/add.py

  • Committer: Martin Pool
  • Date: 2005-08-23 00:27:12 UTC
  • Revision ID: mbp@sourcefrog.net-20050823002712-2b0f5e12243a6116
- merge aaron's merge improvements 999..1008

abentley@panoramicfeedback.com-20050822154931-a0da28d30681e2c6

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