~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

Lalos fix to diff -r x..y ../path/to/branch

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
# Bazaar-NG -- distributed version control
2
 
#
 
2
 
3
3
# Copyright (C) 2005 by Canonical Ltd
4
 
#
 
4
 
5
5
# This program is free software; you can redistribute it and/or modify
6
6
# it under the terms of the GNU General Public License as published by
7
7
# the Free Software Foundation; either version 2 of the License, or
8
8
# (at your option) any later version.
9
 
#
 
9
 
10
10
# This program is distributed in the hope that it will be useful,
11
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
13
# GNU General Public License for more details.
14
 
#
 
14
 
15
15
# You should have received a copy of the GNU General Public License
16
16
# along with this program; if not, write to the Free Software
17
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
 
19
 
from shutil import copyfile
20
 
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
21
 
                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
22
 
from cStringIO import StringIO
23
 
import errno
24
 
import os
25
 
import re
26
 
import sha
27
 
import string
28
 
import sys
29
 
import time
30
 
import types
 
19
import os, types, re, time, errno, sys
 
20
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
31
21
 
 
22
from bzrlib.errors import BzrError
 
23
from bzrlib.trace import mutter
32
24
import bzrlib
33
 
from bzrlib.errors import BzrError, NotBranchError
34
 
from bzrlib.trace import mutter
35
 
 
36
25
 
37
26
def make_readonly(filename):
38
27
    """Make a filename read-only."""
 
28
    # TODO: probably needs to be fixed for windows
39
29
    mod = os.stat(filename).st_mode
40
30
    mod = mod & 0777555
41
31
    os.chmod(filename, mod)
58
48
    # TODO: I'm not really sure this is the best format either.x
59
49
    global _QUOTE_RE
60
50
    if _QUOTE_RE == None:
61
 
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
 
51
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
62
52
        
63
53
    if _QUOTE_RE.search(f):
64
54
        return '"' + f + '"'
74
64
        return 'directory'
75
65
    elif S_ISLNK(mode):
76
66
        return 'symlink'
77
 
    elif S_ISCHR(mode):
78
 
        return 'chardev'
79
 
    elif S_ISBLK(mode):
80
 
        return 'block'
81
 
    elif S_ISFIFO(mode):
82
 
        return 'fifo'
83
 
    elif S_ISSOCK(mode):
84
 
        return 'socket'
85
67
    else:
86
 
        return 'unknown'
 
68
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f))
87
69
 
88
70
 
89
71
def kind_marker(kind):
96
78
    else:
97
79
        raise BzrError('invalid file kind %r' % kind)
98
80
 
99
 
def lexists(f):
100
 
    try:
101
 
        if hasattr(os, 'lstat'):
102
 
            os.lstat(f)
103
 
        else:
104
 
            os.stat(f)
105
 
        return True
106
 
    except OSError,e:
107
 
        if e.errno == errno.ENOENT:
108
 
            return False;
109
 
        else:
110
 
            raise BzrError("lstat/stat of (%r): %r" % (f, e))
111
 
 
112
 
def normalizepath(f):
113
 
    if hasattr(os.path, 'realpath'):
114
 
        F = os.path.realpath
115
 
    else:
116
 
        F = os.path.abspath
117
 
    [p,e] = os.path.split(f)
118
 
    if e == "" or e == "." or e == "..":
119
 
        return F(f)
120
 
    else:
121
 
        return os.path.join(F(p), e)
122
 
 
123
 
if os.name == "posix":
124
 
    # In Python 2.4.2 and older, os.path.abspath and os.path.realpath
125
 
    # choke on a Unicode string containing a relative path if
126
 
    # os.getcwd() returns a non-sys.getdefaultencoding()-encoded
127
 
    # string.
128
 
    _fs_enc = sys.getfilesystemencoding()
129
 
    def abspath(path):
130
 
        return os.path.abspath(path.encode(_fs_enc)).decode(_fs_enc)
131
 
    def realpath(path):
132
 
        return os.path.realpath(path.encode(_fs_enc)).decode(_fs_enc)
133
 
else:
134
 
    # We need to use the Unicode-aware os.path.abspath and
135
 
    # os.path.realpath on Windows systems.
136
 
    abspath = os.path.abspath
137
 
    realpath = os.path.realpath
 
81
 
138
82
 
139
83
def backup_file(fn):
140
84
    """Copy a file to a backup.
143
87
 
144
88
    If the file is already a backup, it's not copied.
145
89
    """
 
90
    import os
146
91
    if fn[-1] == '~':
147
92
        return
148
93
    bfn = fn + '~'
149
94
 
150
 
    if has_symlinks() and os.path.islink(fn):
151
 
        target = os.readlink(fn)
152
 
        os.symlink(target, bfn)
153
 
        return
154
95
    inf = file(fn, 'rb')
155
96
    try:
156
97
        content = inf.read()
163
104
    finally:
164
105
        outf.close()
165
106
 
166
 
if os.name == 'nt':
167
 
    import shutil
168
 
    rename = shutil.move
169
 
else:
170
 
    rename = os.rename
 
107
def rename(path_from, path_to):
 
108
    """Basically the same as os.rename() just special for win32"""
 
109
    if sys.platform == 'win32':
 
110
        try:
 
111
            os.remove(path_to)
 
112
        except OSError, e:
 
113
            if e.errno != e.ENOENT:
 
114
                raise
 
115
    os.rename(path_from, path_to)
 
116
 
 
117
 
 
118
 
171
119
 
172
120
 
173
121
def isdir(f):
178
126
        return False
179
127
 
180
128
 
 
129
 
181
130
def isfile(f):
182
131
    """True if f is a regular file."""
183
132
    try:
185
134
    except OSError:
186
135
        return False
187
136
 
188
 
def islink(f):
189
 
    """True if f is a symlink."""
190
 
    try:
191
 
        return S_ISLNK(os.lstat(f)[ST_MODE])
192
 
    except OSError:
193
 
        return False
194
137
 
195
138
def is_inside(dir, fname):
196
139
    """True if fname is inside dir.
202
145
    The empty string as a dir name is taken as top-of-tree and matches 
203
146
    everything.
204
147
    
205
 
    >>> is_inside('src', os.path.join('src', 'foo.c'))
 
148
    >>> is_inside('src', 'src/foo.c')
206
149
    True
207
150
    >>> is_inside('src', 'srccontrol')
208
151
    False
209
 
    >>> is_inside('src', os.path.join('src', 'a', 'a', 'a', 'foo.c'))
 
152
    >>> is_inside('src', 'src/a/a/a/foo.c')
210
153
    True
211
154
    >>> is_inside('foo.c', 'foo.c')
212
155
    True
222
165
    
223
166
    if dir == '':
224
167
        return True
225
 
 
 
168
    
226
169
    if dir[-1] != os.sep:
227
170
        dir += os.sep
228
 
 
 
171
    
229
172
    return fname.startswith(dir)
230
173
 
231
174
 
243
186
    tofile.write(fromfile.read())
244
187
 
245
188
 
 
189
def uuid():
 
190
    """Return a new UUID"""
 
191
    try:
 
192
        return file('/proc/sys/kernel/random/uuid').readline().rstrip('\n')
 
193
    except IOError:
 
194
        return chomp(os.popen('uuidgen').readline())
 
195
 
 
196
 
246
197
def sha_file(f):
 
198
    import sha
247
199
    if hasattr(f, 'tell'):
248
200
        assert f.tell() == 0
249
201
    s = sha.new()
256
208
    return s.hexdigest()
257
209
 
258
210
 
259
 
 
260
 
def sha_strings(strings):
261
 
    """Return the sha-1 of concatenation of strings"""
262
 
    s = sha.new()
263
 
    map(s.update, strings)
264
 
    return s.hexdigest()
265
 
 
266
 
 
267
211
def sha_string(f):
 
212
    import sha
268
213
    s = sha.new()
269
214
    s.update(f)
270
215
    return s.hexdigest()
271
216
 
272
217
 
 
218
 
273
219
def fingerprint_file(f):
 
220
    import sha
274
221
    s = sha.new()
275
222
    b = f.read()
276
223
    s.update(b)
279
226
            'sha1': s.hexdigest()}
280
227
 
281
228
 
 
229
def config_dir():
 
230
    """Return per-user configuration directory.
 
231
 
 
232
    By default this is ~/.bzr.conf/
 
233
    
 
234
    TODO: Global option --config-dir to override this.
 
235
    """
 
236
    return os.path.expanduser("~/.bzr.conf")
 
237
 
 
238
 
 
239
def _auto_user_id():
 
240
    """Calculate automatic user identification.
 
241
 
 
242
    Returns (realname, email).
 
243
 
 
244
    Only used when none is set in the environment or the id file.
 
245
 
 
246
    This previously used the FQDN as the default domain, but that can
 
247
    be very slow on machines where DNS is broken.  So now we simply
 
248
    use the hostname.
 
249
    """
 
250
    import socket
 
251
 
 
252
    # XXX: Any good way to get real user name on win32?
 
253
 
 
254
    try:
 
255
        import pwd
 
256
        uid = os.getuid()
 
257
        w = pwd.getpwuid(uid)
 
258
        gecos = w.pw_gecos.decode(bzrlib.user_encoding)
 
259
        username = w.pw_name.decode(bzrlib.user_encoding)
 
260
        comma = gecos.find(',')
 
261
        if comma == -1:
 
262
            realname = gecos
 
263
        else:
 
264
            realname = gecos[:comma]
 
265
        if not realname:
 
266
            realname = username
 
267
 
 
268
    except ImportError:
 
269
        import getpass
 
270
        realname = username = getpass.getuser().decode(bzrlib.user_encoding)
 
271
 
 
272
    return realname, (username + '@' + socket.gethostname())
 
273
 
 
274
 
 
275
def _get_user_id(branch):
 
276
    """Return the full user id from a file or environment variable.
 
277
 
 
278
    e.g. "John Hacker <jhacker@foo.org>"
 
279
 
 
280
    branch
 
281
        A branch to use for a per-branch configuration, or None.
 
282
 
 
283
    The following are searched in order:
 
284
 
 
285
    1. $BZREMAIL
 
286
    2. .bzr/email for this branch.
 
287
    3. ~/.bzr.conf/email
 
288
    4. $EMAIL
 
289
    """
 
290
    v = os.environ.get('BZREMAIL')
 
291
    if v:
 
292
        return v.decode(bzrlib.user_encoding)
 
293
 
 
294
    if branch:
 
295
        try:
 
296
            return (branch.controlfile("email", "r") 
 
297
                    .read()
 
298
                    .decode(bzrlib.user_encoding)
 
299
                    .rstrip("\r\n"))
 
300
        except IOError, e:
 
301
            if e.errno != errno.ENOENT:
 
302
                raise
 
303
        except BzrError, e:
 
304
            pass
 
305
    
 
306
    try:
 
307
        return (open(os.path.join(config_dir(), "email"))
 
308
                .read()
 
309
                .decode(bzrlib.user_encoding)
 
310
                .rstrip("\r\n"))
 
311
    except IOError, e:
 
312
        if e.errno != errno.ENOENT:
 
313
            raise e
 
314
 
 
315
    v = os.environ.get('EMAIL')
 
316
    if v:
 
317
        return v.decode(bzrlib.user_encoding)
 
318
    else:    
 
319
        return None
 
320
 
 
321
 
 
322
def username(branch):
 
323
    """Return email-style username.
 
324
 
 
325
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
 
326
 
 
327
    TODO: Check it's reasonably well-formed.
 
328
    """
 
329
    v = _get_user_id(branch)
 
330
    if v:
 
331
        return v
 
332
    
 
333
    name, email = _auto_user_id()
 
334
    if name:
 
335
        return '%s <%s>' % (name, email)
 
336
    else:
 
337
        return email
 
338
 
 
339
 
 
340
def user_email(branch):
 
341
    """Return just the email component of a username."""
 
342
    e = _get_user_id(branch)
 
343
    if e:
 
344
        m = re.search(r'[\w+.-]+@[\w+.-]+', e)
 
345
        if not m:
 
346
            raise BzrError("%r doesn't seem to contain a reasonable email address" % e)
 
347
        return m.group(0)
 
348
 
 
349
    return _auto_user_id()[1]
 
350
    
 
351
 
 
352
 
282
353
def compare_files(a, b):
283
354
    """Returns true if equal in contents"""
284
355
    BUFSIZE = 4096
291
362
            return True
292
363
 
293
364
 
 
365
 
294
366
def local_time_offset(t=None):
295
367
    """Return offset of local zone from GMT, either at present or at time t."""
296
368
    # python2.3 localtime() can't take None
303
375
        return -time.timezone
304
376
 
305
377
    
306
 
def format_date(t, offset=0, timezone='original', date_fmt=None, 
307
 
                show_offset=True):
 
378
def format_date(t, offset=0, timezone='original'):
308
379
    ## TODO: Perhaps a global option to use either universal or local time?
309
380
    ## Or perhaps just let people set $TZ?
310
381
    assert isinstance(t, float)
322
393
    else:
323
394
        raise BzrError("unsupported timezone format %r" % timezone,
324
395
                       ['options are "utc", "original", "local"'])
325
 
    if date_fmt is None:
326
 
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
327
 
    if show_offset:
328
 
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
329
 
    else:
330
 
        offset_str = ''
331
 
    return (time.strftime(date_fmt, tt) +  offset_str)
 
396
 
 
397
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
 
398
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
332
399
 
333
400
 
334
401
def compact_date(when):
412
479
        return os.path.join(p1, p2)
413
480
    
414
481
 
415
 
def split_lines(s):
416
 
    """Split s into lines, but without removing the newline characters."""
417
 
    return StringIO(s).readlines()
418
 
 
419
 
 
420
 
def hardlinks_good():
421
 
    return sys.platform not in ('win32', 'cygwin', 'darwin')
422
 
 
423
 
 
424
 
def link_or_copy(src, dest):
425
 
    """Hardlink a file, or copy it if it can't be hardlinked."""
426
 
    if not hardlinks_good():
427
 
        copyfile(src, dest)
428
 
        return
 
482
def extern_command(cmd, ignore_errors = False):
 
483
    mutter('external command: %s' % `cmd`)
 
484
    if os.system(cmd):
 
485
        if not ignore_errors:
 
486
            raise BzrError('command failed')
 
487
 
 
488
 
 
489
def _read_config_value(name):
 
490
    """Read a config value from the file ~/.bzr.conf/<name>
 
491
    Return None if the file does not exist"""
429
492
    try:
430
 
        os.link(src, dest)
431
 
    except (OSError, IOError), e:
432
 
        if e.errno != errno.EXDEV:
433
 
            raise
434
 
        copyfile(src, dest)
435
 
 
436
 
 
437
 
def has_symlinks():
438
 
    if hasattr(os, 'symlink'):
439
 
        return True
440
 
    else:
441
 
        return False
442
 
        
443
 
 
444
 
def contains_whitespace(s):
445
 
    """True if there are any whitespace characters in s."""
446
 
    for ch in string.whitespace:
447
 
        if ch in s:
448
 
            return True
449
 
    else:
450
 
        return False
451
 
 
452
 
 
453
 
def contains_linebreaks(s):
454
 
    """True if there is any vertical whitespace in s."""
455
 
    for ch in '\f\n\r':
456
 
        if ch in s:
457
 
            return True
458
 
    else:
459
 
        return False
460
 
 
461
 
 
462
 
def relpath(base, path):
463
 
    """Return path relative to base, or raise exception.
464
 
 
465
 
    The path may be either an absolute path or a path relative to the
466
 
    current working directory.
467
 
 
468
 
    os.path.commonprefix (python2.4) has a bad bug that it works just
469
 
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
470
 
    avoids that problem."""
471
 
    rp = abspath(path)
472
 
 
473
 
    s = []
474
 
    head = rp
475
 
    while len(head) >= len(base):
476
 
        if head == base:
477
 
            break
478
 
        head, tail = os.path.split(head)
479
 
        if tail:
480
 
            s.insert(0, tail)
481
 
    else:
482
 
        # XXX This should raise a NotChildPath exception, as its not tied
483
 
        # to branch anymore.
484
 
        raise NotBranchError("path %r is not within branch %r" % (rp, base))
485
 
 
486
 
    return os.sep.join(s)
 
493
        f = file(os.path.join(config_dir(), name), "r")
 
494
        return f.read().decode(bzrlib.user_encoding).rstrip("\r\n")
 
495
    except IOError, e:
 
496
        if e.errno == errno.ENOENT:
 
497
            return None
 
498
        raise
 
499
 
 
500