~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/add.py

  • Committer: Lalo Martins
  • Date: 2005-09-13 09:52:12 UTC
  • mto: (1185.1.22)
  • mto: This revision was merged to the branch mainline in revision 1390.
  • Revision ID: lalo@exoweb.net-20050913095212-210555d61a893f1e
fixing up users of RevisionSpec, and moving it over to commands.py
(single point)

There are still a few users who could move, but that's a thought for
later... when someone sits down to separate UI from backend code.

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