~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

• browse files at revision 2625.10.1
• compare with another revision
• download diff
• download tarball
• view history from revision 2625.10.1

• reverse the comparison (2625.10.1 to 4371.4.20)
• stop comparing with revision 4371.4.20

Show diffs side-by-side

added

removed

bzrlib/urlutils.py

1

 

# Copyright (C) 2006, 2008 Canonical Ltd

 

1

# Bazaar -- distributed version control

 

2

#

 

3

# Copyright (C) 2006 Canonical Ltd

2

4

#

3

5

# This program is free software; you can redistribute it and/or modify

4

6

# it under the terms of the GNU General Public License as published by

12

14

#

13

15

# You should have received a copy of the GNU General Public License

14

16

# along with this program; if not, write to the Free Software

15

 

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 

17

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

16

18

 

17

19

"""A collection of function for handling URL operations."""

18

20

 

24

26

lazy_import(globals(), """

25

27

from posixpath import split as _posix_split, normpath as _posix_normpath

26

28

import urllib

27

 

import urlparse

28

29

 

29

30

from bzrlib import (

30

31

    errors,

66

67

        relpath = relpath.encode('utf-8')

67

68

    # After quoting and encoding, the path should be perfectly

68

69

    # safe as a plain ASCII string, str() just enforces this

69

 

    return str(urllib.quote(relpath, safe='/~'))

 

70

    return str(urllib.quote(relpath))

70

71

 

71

72

 

72

73

def file_relpath(base, path):

73

74

    """Compute just the relative sub-portion of a url

74

 

 

 

75

    

75

76

    This assumes that both paths are already fully specified file:// URLs.

76

77

    """

77

 

    if len(base) < MIN_ABS_FILEURL_LENGTH:

78

 

        raise ValueError('Length of base must be equal or'

79

 

            ' exceed the platform minimum url length (which is %d)' %

80

 

            MIN_ABS_FILEURL_LENGTH)

 

78

    assert len(base) >= MIN_ABS_FILEURL_LENGTH, ('Length of base must be equal or'

 

79

        ' exceed the platform minimum url length (which is %d)' % 

 

80

        MIN_ABS_FILEURL_LENGTH)

 

81

 

81

82

    base = local_path_from_url(base)

82

83

    path = local_path_from_url(path)

83

84

    return escape(osutils.relpath(base, path))

183

184

 

184

185

def joinpath(base, *args):

185

186

    """Join URL path segments to a URL path segment.

186

 

 

 

187

    

187

188

    This is somewhat like osutils.joinpath, but intended for URLs.

188

189

 

189

190

    XXX: this duplicates some normalisation logic, and also duplicates a lot of

228

229

 

229

230

    This also handles transforming escaping unicode characters, etc.

230

231

    """

231

 

    # importing directly from posixpath allows us to test this

 

232

    # importing directly from posixpath allows us to test this 

232

233

    # on non-posix platforms

233

234

    return 'file://' + escape(_posix_normpath(

234

235

        osutils._posix_abspath(path)))

248

249

            raise errors.InvalidURL(url, 'Win32 UNC path urls'

249

250

                ' have form file://HOST/path')

250

251

        return unescape(win32_url)

251

 

 

252

 

    # allow empty paths so we can serve all roots

253

 

    if win32_url == '///':

254

 

        return '/'

255

 

 

256

252

    # usual local path with drive letter

257

253

    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'

258

254

                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')

268

264

 

269

265

    This also handles transforming escaping unicode characters, etc.

270

266

    """

271

 

    # importing directly from ntpath allows us to test this

 

267

    # importing directly from ntpath allows us to test this 

272

268

    # on non-win32 platform

273

269

    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname

274

270

    #       which actually strips trailing space characters.

275

271

    #       The worst part is that under linux ntpath.abspath has different

276

272

    #       semantics, since 'nt' is not an available module.

277

 

    if path == '/':

278

 

        return 'file:///'

279

 

 

280

273

    win32_path = osutils._win32_abspath(path)

281

274

    # check for UNC path \\HOST\path

282

275

    if win32_path.startswith('//'):

283

276

        return 'file:' + escape(win32_path)

284

 

    return ('file:///' + str(win32_path[0].upper()) + ':' +

285

 

        escape(win32_path[2:]))

 

277

    return 'file:///' + win32_path[0].upper() + ':' + escape(win32_path[2:])

286

278

 

287

279

 

288

280

local_path_to_url = _posix_local_path_to_url

303

295

 

304

296

def _unescape_safe_chars(matchobj):

305

297

    """re.sub callback to convert hex-escapes to plain characters (if safe).

306

 

 

 

298

    

307

299

    e.g. '%7E' will be converted to '~'.

308

300

    """

309

301

    hex_digits = matchobj.group(0)[1:]

316

308

 

317

309

def normalize_url(url):

318

310

    """Make sure that a path string is in fully normalized URL form.

319

 

 

 

311

    

320

312

    This handles URLs which have unicode characters, spaces,

321

313

    special characters, etc.

322

314

 

368

360

    dummy, base_first_slash = _find_scheme_and_separator(base)

369

361

    if base_first_slash is None:

370

362

        return other

371

 

 

 

363

    

372

364

    dummy, other_first_slash = _find_scheme_and_separator(other)

373

365

    if other_first_slash is None:

374

366

        return other

378

370

    other_scheme = other[:other_first_slash]

379

371

    if base_scheme != other_scheme:

380

372

        return other

381

 

    elif sys.platform == 'win32' and base_scheme == 'file://':

382

 

        base_drive = base[base_first_slash+1:base_first_slash+3]

383

 

        other_drive = other[other_first_slash+1:other_first_slash+3]

384

 

        if base_drive != other_drive:

385

 

            return other

386

373

 

387

374

    base_path = base[base_first_slash+1:]

388

375

    other_path = other[other_first_slash+1:]

416

403

    # Strip off the drive letter

417

404

    # path is currently /C:/foo

418

405

    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':

419

 

        raise errors.InvalidURL(url_base + path,

 

406

        raise errors.InvalidURL(url_base + path, 

420

407

            'win32 file:/// paths need a drive letter')

421

408

    url_base += path[0:3] # file:// + /C:

422

409

    path = path[3:] # /foo

430

417

    :param exclude_trailing_slash: Strip off a final '/' if it is part

431

418

        of the path (but not if it is part of the protocol specification)

432

419

 

433

 

    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at

 

420

    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at 

434

421

        the root.

435

422

    """

436

423

    scheme_loc, first_path_slash = _find_scheme_and_separator(url)

540

527

# These are characters that if escaped, should stay that way

541

528

_no_decode_chars = ';/?:@&=+$,#'

542

529

_no_decode_ords = [ord(c) for c in _no_decode_chars]

543

 

_no_decode_hex = (['%02x' % o for o in _no_decode_ords]

 

530

_no_decode_hex = (['%02x' % o for o in _no_decode_ords] 

544

531

                + ['%02X' % o for o in _no_decode_ords])

545

532

_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]

546

533

                    + [('%02X' % o, chr(o)) for o in range(256)]))

572

559

    This will turn file:// urls into local paths, and try to decode

573

560

    any portions of a http:// style url that it can.

574

561

 

575

 

    Any sections of the URL which can't be represented in the encoding or

 

562

    Any sections of the URL which can't be represented in the encoding or 

576

563

    need to stay as escapes are left alone.

577

564

 

578

565

    :param url: A 7-bit ASCII URL

579

566

    :param encoding: The final output encoding

580

567

 

581

 

    :return: A unicode string which can be safely encoded into the

 

568

    :return: A unicode string which can be safely encoded into the 

582

569

         specified encoding.

583

570

    """

584

 

    if encoding is None:

585

 

        raise ValueError('you cannot specify None for the display encoding')

 

571

    assert encoding is not None, 'you cannot specify None for the display encoding.'

586

572

    if url.startswith('file://'):

587

573

        try:

588

574

            path = local_path_from_url(url)

643

629

            return from_location[sep+1:]

644

630

        else:

645

631

            return from_location

646

 

 

647

 

 

648

 

def _is_absolute(url):

649

 

    return (osutils.pathjoin('/foo', url) == url)

650

 

 

651

 

 

652

 

def rebase_url(url, old_base, new_base):

653

 

    """Convert a relative path from an old base URL to a new base URL.

654

 

 

655

 

    The result will be a relative path.

656

 

    Absolute paths and full URLs are returned unaltered.

657

 

    """

658

 

    scheme, separator = _find_scheme_and_separator(url)

659

 

    if scheme is not None:

660

 

        return url

661

 

    if _is_absolute(url):

662

 

        return url

663

 

    old_parsed = urlparse.urlparse(old_base)

664

 

    new_parsed = urlparse.urlparse(new_base)

665

 

    if (old_parsed[:2]) != (new_parsed[:2]):

666

 

        raise errors.InvalidRebaseURLs(old_base, new_base)

667

 

    return determine_relative_path(new_parsed[2],

668

 

                                   join(old_parsed[2], url))

669

 

 

670

 

 

671

 

def determine_relative_path(from_path, to_path):

672

 

    """Determine a relative path from from_path to to_path."""

673

 

    from_segments = osutils.splitpath(from_path)

674

 

    to_segments = osutils.splitpath(to_path)

675

 

    count = -1

676

 

    for count, (from_element, to_element) in enumerate(zip(from_segments,

677

 

                                                       to_segments)):

678

 

        if from_element != to_element:

679

 

            break

680

 

    else:

681

 

        count += 1

682

 

    unique_from = from_segments[count:]

683

 

    unique_to = to_segments[count:]

684

 

    segments = (['..'] * len(unique_from) + unique_to)

685

 

    if len(segments) == 0:

686

 

        return '.'

687

 

    return osutils.pathjoin(*segments)

688

 

 

689

 

 

690

 

 

691

 

def parse_url(url):

692

 

    """Extract the server address, the credentials and the path from the url.

693

 

 

694

 

    user, password, host and path should be quoted if they contain reserved

695

 

    chars.

696

 

 

697

 

    :param url: an quoted url

698

 

 

699

 

    :return: (scheme, user, password, host, port, path) tuple, all fields

700

 

        are unquoted.

701

 

    """

702

 

    if isinstance(url, unicode):

703

 

        raise errors.InvalidURL('should be ascii:\n%r' % url)

704

 

    url = url.encode('utf-8')

705

 

    (scheme, netloc, path, params,

706

 

     query, fragment) = urlparse.urlparse(url, allow_fragments=False)

707

 

    user = password = host = port = None

708

 

    if '@' in netloc:

709

 

        user, host = netloc.rsplit('@', 1)

710

 

        if ':' in user:

711

 

            user, password = user.split(':', 1)

712

 

            password = urllib.unquote(password)

713

 

        user = urllib.unquote(user)

714

 

    else:

715

 

        host = netloc

716

 

 

717

 

    if ':' in host and not (host[0] == '[' and host[-1] == ']'): #there *is* port

718

 

        host, port = host.rsplit(':',1)

719

 

        try:

720

 

            port = int(port)

721

 

        except ValueError:

722

 

            raise errors.InvalidURL('invalid port number %s in url:\n%s' %

723

 

                                    (port, url))

724

 

    if host != "" and host[0] == '[' and host[-1] == ']': #IPv6

725

 

        host = host[1:-1]

726

 

 

727

 

    host = urllib.unquote(host)

728

 

    path = urllib.unquote(path)

729

 

 

730

 

    return (scheme, user, password, host, port, path)

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1