← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Martin Pool
  • Date: 2005-08-18 06:20:49 UTC
  • Revision ID: mbp@sourcefrog.net-20050818062049-466ffa0cf0d80592
- weavefile can just use lists for read-in ancestry, not frozensets

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
21
21
# it's not predictable when it will be written out.
22
22
 
23
23
import os
24
 
import stat
25
 
import fnmatch
26
 
        
 
24
    
27
25
import bzrlib.tree
28
 
from bzrlib.osutils import appendpath, file_kind, isdir, splitpath
29
 
from bzrlib.errors import BzrCheckError
30
 
from bzrlib.trace import mutter
31
 
 
32
 
class TreeEntry(object):
33
 
    """An entry that implements the minium interface used by commands.
34
 
 
35
 
    This needs further inspection, it may be better to have 
36
 
    InventoryEntries without ids - though that seems wrong. For now,
37
 
    this is a parallel hierarchy to InventoryEntry, and needs to become
38
 
    one of several things: decorates to that hierarchy, children of, or
39
 
    parents of it.
40
 
    Another note is that these objects are currently only used when there is
41
 
    no InventoryEntry available - i.e. for unversioned objects.
42
 
    Perhaps they should be UnversionedEntry et al. ? - RBC 20051003
43
 
    """
44
 
 
45
 
    def __eq__(self, other):
46
 
        # yes, this us ugly, TODO: best practice __eq__ style.
47
 
        return (isinstance(other, TreeEntry)
48
 
                and other.__class__ == self.__class__)
49
 
 
50
 
    def kind_character(self):
51
 
        return "???"
52
 
 
53
 
 
54
 
class TreeDirectory(TreeEntry):
55
 
    """See TreeEntry. This is a directory in a working tree."""
56
 
 
57
 
    def __eq__(self, other):
58
 
        return (isinstance(other, TreeDirectory)
59
 
                and other.__class__ == self.__class__)
60
 
 
61
 
    def kind_character(self):
62
 
        return "/"
63
 
 
64
 
 
65
 
class TreeFile(TreeEntry):
66
 
    """See TreeEntry. This is a regular file in a working tree."""
67
 
 
68
 
    def __eq__(self, other):
69
 
        return (isinstance(other, TreeFile)
70
 
                and other.__class__ == self.__class__)
71
 
 
72
 
    def kind_character(self):
73
 
        return ''
74
 
 
75
 
 
76
 
class TreeLink(TreeEntry):
77
 
    """See TreeEntry. This is a symlink in a working tree."""
78
 
 
79
 
    def __eq__(self, other):
80
 
        return (isinstance(other, TreeLink)
81
 
                and other.__class__ == self.__class__)
82
 
 
83
 
    def kind_character(self):
84
 
        return ''
85
 
 
 
26
from errors import BzrCheckError
 
27
from trace import mutter
86
28
 
87
29
class WorkingTree(bzrlib.tree.Tree):
88
30
    """Working copy tree.
125
67
        """
126
68
        inv = self._inventory
127
69
        for path, ie in inv.iter_entries():
128
 
            if bzrlib.osutils.lexists(self.abspath(path)):
 
70
            if os.path.exists(self.abspath(path)):
129
71
                yield ie.file_id
130
72
 
131
73
 
139
81
        return os.path.join(self.basedir, filename)
140
82
 
141
83
    def has_filename(self, filename):
142
 
        return bzrlib.osutils.lexists(self.abspath(filename))
 
84
        return os.path.exists(self.abspath(filename))
143
85
 
144
86
    def get_file(self, file_id):
145
87
        return self.get_file_byname(self.id2path(file_id))
151
93
        ## XXX: badly named; this isn't in the store at all
152
94
        return self.abspath(self.id2path(file_id))
153
95
 
154
 
 
155
 
    def id2abspath(self, file_id):
156
 
        return self.abspath(self.id2path(file_id))
157
 
 
158
96
                
159
97
    def has_id(self, file_id):
160
98
        # files that have been deleted are excluded
162
100
        if not inv.has_id(file_id):
163
101
            return False
164
102
        path = inv.id2path(file_id)
165
 
        return bzrlib.osutils.lexists(self.abspath(path))
 
103
        return os.path.exists(self.abspath(path))
166
104
 
167
105
 
168
106
    __contains__ = has_id
169
107
    
170
108
 
171
109
    def get_file_size(self, file_id):
172
 
        return os.path.getsize(self.id2abspath(file_id))
 
110
        # is this still called?
 
111
        raise NotImplementedError()
 
112
 
173
113
 
174
114
    def get_file_sha1(self, file_id):
175
115
        path = self._inventory.id2path(file_id)
176
116
        return self._hashcache.get_sha1(path)
177
117
 
178
118
 
179
 
    def is_executable(self, file_id):
180
 
        if os.name == "nt":
181
 
            return self._inventory[file_id].executable
182
 
        else:
183
 
            path = self._inventory.id2path(file_id)
184
 
            mode = os.lstat(self.abspath(path)).st_mode
185
 
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC&mode)
186
 
 
187
 
    def get_symlink_target(self, file_id):
188
 
        return os.readlink(self.id2abspath(file_id))
189
 
 
190
119
    def file_class(self, filename):
191
120
        if self.path2id(filename):
192
121
            return 'V'
206
135
 
207
136
        Skips the control directory.
208
137
        """
 
138
        from osutils import appendpath, file_kind
 
139
        import os
 
140
 
209
141
        inv = self._inventory
210
142
 
211
143
        def descend(from_dir_relpath, from_dir_id, dp):
240
172
                                            "now of kind %r"
241
173
                                            % (fap, f_ie.kind, f_ie.file_id, fk))
242
174
 
243
 
                # make a last minute entry
244
 
                if f_ie:
245
 
                    entry = f_ie
246
 
                else:
247
 
                    if fk == 'directory':
248
 
                        entry = TreeDirectory()
249
 
                    elif fk == 'file':
250
 
                        entry = TreeFile()
251
 
                    elif fk == 'symlink':
252
 
                        entry = TreeLink()
253
 
                    else:
254
 
                        entry = TreeEntry()
255
 
                
256
 
                yield fp, c, fk, (f_ie and f_ie.file_id), entry
 
175
                yield fp, c, fk, (f_ie and f_ie.file_id)
257
176
 
258
177
                if fk != 'directory':
259
178
                    continue
275
194
            if not self.is_ignored(subp):
276
195
                yield subp
277
196
 
278
 
    def iter_conflicts(self):
279
 
        conflicted = set()
280
 
        for path in (s[0] for s in self.list_files()):
281
 
            stem = get_conflicted_stem(path)
282
 
            if stem is None:
283
 
                continue
284
 
            if stem not in conflicted:
285
 
                conflicted.add(stem)
286
 
                yield stem
287
197
 
288
198
    def extras(self):
289
199
        """Yield all unknown files in this WorkingTree.
295
205
        Currently returned depth-first, sorted by name within directories.
296
206
        """
297
207
        ## TODO: Work from given directory downwards
 
208
        from osutils import isdir, appendpath
 
209
        
298
210
        for path, dir_entry in self.inventory.directories():
299
211
            mutter("search for unknowns in %r" % path)
300
212
            dirabs = self.abspath(path)
357
269
        # Eventually it should be replaced with something more
358
270
        # accurate.
359
271
        
 
272
        import fnmatch
 
273
        from osutils import splitpath
 
274
        
360
275
        for pat in self.get_ignore_list():
361
276
            if '/' in pat or '\\' in pat:
362
277
                
375
290
                    return pat
376
291
        else:
377
292
            return None
378
 
 
379
 
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
380
 
def get_conflicted_stem(path):
381
 
    for suffix in CONFLICT_SUFFIXES:
382
 
        if path.endswith(suffix):
383
 
            return path[:-len(suffix)]
 
293
        
 
 
b'\\ No newline at end of file'