~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Robert Collins
  • Date: 2005-10-19 10:11:57 UTC
  • mfrom: (1185.16.78)
  • mto: This revision was merged to the branch mainline in revision 1470.
  • Revision ID: robertc@robertcollins.net-20051019101157-17438d311e746b4f
mergeĀ fromĀ upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
24
24
import os
25
25
import re
26
26
import sha
 
27
import string
27
28
import sys
28
29
import time
29
30
import types
30
31
 
31
32
import bzrlib
32
 
from bzrlib.errors import BzrError
 
33
from bzrlib.errors import BzrError, NotBranchError
33
34
from bzrlib.trace import mutter
34
35
 
35
36
 
118
119
        return F(f)
119
120
    else:
120
121
        return os.path.join(F(p), e)
121
 
    
 
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
122
138
 
123
139
def backup_file(fn):
124
140
    """Copy a file to a backup.
131
147
        return
132
148
    bfn = fn + '~'
133
149
 
 
150
    if has_symlinks() and os.path.islink(fn):
 
151
        target = os.readlink(fn)
 
152
        os.symlink(target, bfn)
 
153
        return
134
154
    inf = file(fn, 'rb')
135
155
    try:
136
156
        content = inf.read()
259
279
            'sha1': s.hexdigest()}
260
280
 
261
281
 
262
 
def config_dir():
263
 
    """Return per-user configuration directory.
264
 
 
265
 
    By default this is ~/.bzr.conf/
266
 
    
267
 
    TODO: Global option --config-dir to override this.
268
 
    """
269
 
    return os.path.join(os.path.expanduser("~"), ".bzr.conf")
270
 
 
271
 
 
272
 
def _auto_user_id():
273
 
    """Calculate automatic user identification.
274
 
 
275
 
    Returns (realname, email).
276
 
 
277
 
    Only used when none is set in the environment or the id file.
278
 
 
279
 
    This previously used the FQDN as the default domain, but that can
280
 
    be very slow on machines where DNS is broken.  So now we simply
281
 
    use the hostname.
282
 
    """
283
 
    import socket
284
 
 
285
 
    # XXX: Any good way to get real user name on win32?
286
 
 
287
 
    try:
288
 
        import pwd
289
 
        uid = os.getuid()
290
 
        w = pwd.getpwuid(uid)
291
 
        gecos = w.pw_gecos.decode(bzrlib.user_encoding)
292
 
        username = w.pw_name.decode(bzrlib.user_encoding)
293
 
        comma = gecos.find(',')
294
 
        if comma == -1:
295
 
            realname = gecos
296
 
        else:
297
 
            realname = gecos[:comma]
298
 
        if not realname:
299
 
            realname = username
300
 
 
301
 
    except ImportError:
302
 
        import getpass
303
 
        realname = username = getpass.getuser().decode(bzrlib.user_encoding)
304
 
 
305
 
    return realname, (username + '@' + socket.gethostname())
306
 
 
307
 
 
308
 
def _get_user_id(branch):
309
 
    """Return the full user id from a file or environment variable.
310
 
 
311
 
    e.g. "John Hacker <jhacker@foo.org>"
312
 
 
313
 
    branch
314
 
        A branch to use for a per-branch configuration, or None.
315
 
 
316
 
    The following are searched in order:
317
 
 
318
 
    1. $BZREMAIL
319
 
    2. .bzr/email for this branch.
320
 
    3. ~/.bzr.conf/email
321
 
    4. $EMAIL
322
 
    """
323
 
    v = os.environ.get('BZREMAIL')
324
 
    if v:
325
 
        return v.decode(bzrlib.user_encoding)
326
 
 
327
 
    if branch:
328
 
        try:
329
 
            return (branch.controlfile("email", "r") 
330
 
                    .read()
331
 
                    .decode(bzrlib.user_encoding)
332
 
                    .rstrip("\r\n"))
333
 
        except IOError, e:
334
 
            if e.errno != errno.ENOENT:
335
 
                raise
336
 
        except BzrError, e:
337
 
            pass
338
 
    
339
 
    try:
340
 
        return (open(os.path.join(config_dir(), "email"))
341
 
                .read()
342
 
                .decode(bzrlib.user_encoding)
343
 
                .rstrip("\r\n"))
344
 
    except IOError, e:
345
 
        if e.errno != errno.ENOENT:
346
 
            raise e
347
 
 
348
 
    v = os.environ.get('EMAIL')
349
 
    if v:
350
 
        return v.decode(bzrlib.user_encoding)
351
 
    else:    
352
 
        return None
353
 
 
354
 
 
355
 
def username(branch):
356
 
    """Return email-style username.
357
 
 
358
 
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
359
 
 
360
 
    TODO: Check it's reasonably well-formed.
361
 
    """
362
 
    v = _get_user_id(branch)
363
 
    if v:
364
 
        return v
365
 
    
366
 
    name, email = _auto_user_id()
367
 
    if name:
368
 
        return '%s <%s>' % (name, email)
369
 
    else:
370
 
        return email
371
 
 
372
 
 
373
 
def user_email(branch):
374
 
    """Return just the email component of a username."""
375
 
    e = _get_user_id(branch)
376
 
    if e:
377
 
        m = re.search(r'[\w+.-]+@[\w+.-]+', e)
378
 
        if not m:
379
 
            raise BzrError("%r doesn't seem to contain "
380
 
                           "a reasonable email address" % e)
381
 
        return m.group(0)
382
 
 
383
 
    return _auto_user_id()[1]
384
 
 
385
 
 
386
282
def compare_files(a, b):
387
283
    """Returns true if equal in contents"""
388
284
    BUFSIZE = 4096
407
303
        return -time.timezone
408
304
 
409
305
    
410
 
def format_date(t, offset=0, timezone='original'):
 
306
def format_date(t, offset=0, timezone='original', date_fmt=None, 
 
307
                show_offset=True):
411
308
    ## TODO: Perhaps a global option to use either universal or local time?
412
309
    ## Or perhaps just let people set $TZ?
413
310
    assert isinstance(t, float)
425
322
    else:
426
323
        raise BzrError("unsupported timezone format %r" % timezone,
427
324
                       ['options are "utc", "original", "local"'])
428
 
 
429
 
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
430
 
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
 
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)
431
332
 
432
333
 
433
334
def compact_date(when):
511
412
        return os.path.join(p1, p2)
512
413
    
513
414
 
514
 
def _read_config_value(name):
515
 
    """Read a config value from the file ~/.bzr.conf/<name>
516
 
    Return None if the file does not exist"""
517
 
    try:
518
 
        f = file(os.path.join(config_dir(), name), "r")
519
 
        return f.read().decode(bzrlib.user_encoding).rstrip("\r\n")
520
 
    except IOError, e:
521
 
        if e.errno == errno.ENOENT:
522
 
            return None
523
 
        raise
524
 
 
525
 
 
526
415
def split_lines(s):
527
416
    """Split s into lines, but without removing the newline characters."""
528
417
    return StringIO(s).readlines()
550
439
        return True
551
440
    else:
552
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)