/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

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

• reverse the comparison (3806.1.1 to 5280)
• stop comparing with revision 5280

Show diffs side-by-side

added

removed

bzrlib/urlutils.py

1

 

# Copyright (C) 2006-2010 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

 

66

68

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

67

69

    # After quoting and encoding, the path should be perfectly

68

70

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

69

 

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

 

71

    return str(urllib.quote(relpath))

70

72

 

71

73

 

72

74

def file_relpath(base, path):

73

75

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

74

 

 

 

76

    

75

77

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

76

78

    """

77

79

    if len(base) < MIN_ABS_FILEURL_LENGTH:

78

 

        raise ValueError('Length of base (%r) must equal or'

 

80

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

79

81

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

80

 

            (base, MIN_ABS_FILEURL_LENGTH))

 

82

            MIN_ABS_FILEURL_LENGTH)

81

83

    base = local_path_from_url(base)

82

84

    path = local_path_from_url(path)

83

85

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

183

185

 

184

186

def joinpath(base, *args):

185

187

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

186

 

 

 

188

    

187

189

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

188

190

 

189

191

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

217

219

# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'

218

220

def _posix_local_path_from_url(url):

219

221

    """Convert a url like file:///path/to/foo into /path/to/foo"""

220

 

    file_localhost_prefix = 'file://localhost/'

221

 

    if url.startswith(file_localhost_prefix):

222

 

        path = url[len(file_localhost_prefix) - 1:]

223

 

    elif not url.startswith('file:///'):

224

 

        raise errors.InvalidURL(

225

 

            url, 'local urls must start with file:/// or file://localhost/')

226

 

    else:

227

 

        path = url[len('file://'):]

 

222

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

 

223

        raise errors.InvalidURL(url, 'local urls must start with file:///')

228

224

    # We only strip off 2 slashes

229

 

    return unescape(path)

 

225

    return unescape(url[len('file://'):])

230

226

 

231

227

 

232

228

def _posix_local_path_to_url(path):

234

230

 

235

231

    This also handles transforming escaping unicode characters, etc.

236

232

    """

237

 

    # importing directly from posixpath allows us to test this

 

233

    # importing directly from posixpath allows us to test this 

238

234

    # on non-posix platforms

239

235

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

240

236

        osutils._posix_abspath(path)))

258

254

    # allow empty paths so we can serve all roots

259

255

    if win32_url == '///':

260

256

        return '/'

261

 

 

 

257

    

262

258

    # usual local path with drive letter

263

259

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

264

260

                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')

274

270

 

275

271

    This also handles transforming escaping unicode characters, etc.

276

272

    """

277

 

    # importing directly from ntpath allows us to test this

 

273

    # importing directly from ntpath allows us to test this 

278

274

    # on non-win32 platform

279

275

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

280

276

    #       which actually strips trailing space characters.

281

 

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

 

277

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

282

278

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

283

279

    if path == '/':

284

280

        return 'file:///'

309

305

 

310

306

def _unescape_safe_chars(matchobj):

311

307

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

312

 

 

 

308

    

313

309

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

314

310

    """

315

311

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

322

318

 

323

319

def normalize_url(url):

324

320

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

325

 

 

 

321

    

326

322

    This handles URLs which have unicode characters, spaces,

327

323

    special characters, etc.

328

324

 

374

370

    dummy, base_first_slash = _find_scheme_and_separator(base)

375

371

    if base_first_slash is None:

376

372

        return other

377

 

 

 

373

    

378

374

    dummy, other_first_slash = _find_scheme_and_separator(other)

379

375

    if other_first_slash is None:

380

376

        return other

422

418

    # Strip off the drive letter

423

419

    # path is currently /C:/foo

424

420

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

425

 

        raise errors.InvalidURL(url_base + path,

 

421

        raise errors.InvalidURL(url_base + path, 

426

422

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

427

423

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

428

424

    path = path[3:] # /foo

436

432

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

437

433

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

438

434

 

439

 

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

 

435

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

440

436

        the root.

441

437

    """

442

438

    scheme_loc, first_path_slash = _find_scheme_and_separator(url)

469

465

    return url_base + head, tail

470

466

 

471

467

 

472

 

def split_segment_parameters_raw(url):

473

 

    """Split the subsegment of the last segment of a URL.

474

 

 

475

 

    :param url: A relative or absolute URL

476

 

    :return: (url, subsegments)

477

 

    """

478

 

    (parent_url, child_dir) = split(url)

479

 

    subsegments = child_dir.split(",")

480

 

    if len(subsegments) == 1:

481

 

        return (url, [])

482

 

    return (join(parent_url, subsegments[0]), subsegments[1:])

483

 

 

484

 

 

485

 

def split_segment_parameters(url):

486

 

    """Split the segment parameters of the last segment of a URL.

487

 

 

488

 

    :param url: A relative or absolute URL

489

 

    :return: (url, segment_parameters)

490

 

    """

491

 

    (base_url, subsegments) = split_segment_parameters_raw(url)

492

 

    parameters = {}

493

 

    for subsegment in subsegments:

494

 

        (key, value) = subsegment.split("=", 1)

495

 

        parameters[key] = value

496

 

    return (base_url, parameters)

497

 

 

498

 

 

499

 

def join_segment_parameters_raw(base, *subsegments):

500

 

    """Create a new URL by adding subsegments to an existing one. 

501

 

 

502

 

    This adds the specified subsegments to the last path in the specified

503

 

    base URL. The subsegments should be bytestrings.

504

 

 

505

 

    :note: You probably want to use join_segment_parameters instead.

506

 

    """

507

 

    if not subsegments:

508

 

        return base

509

 

    for subsegment in subsegments:

510

 

        if type(subsegment) is not str:

511

 

            raise TypeError("Subsegment %r is not a bytestring" % subsegment)

512

 

        if "," in subsegment:

513

 

            raise errors.InvalidURLJoin(", exists in subsegments",

514

 

                                        base, subsegments)

515

 

    return ",".join((base,) + subsegments)

516

 

 

517

 

 

518

 

def join_segment_parameters(url, parameters):

519

 

    """Create a new URL by adding segment parameters to an existing one.

520

 

 

521

 

    The parameters of the last segment in the URL will be updated; if a

522

 

    parameter with the same key already exists it will be overwritten.

523

 

 

524

 

    :param url: A URL, as string

525

 

    :param parameters: Dictionary of parameters, keys and values as bytestrings

526

 

    """

527

 

    (base, existing_parameters) = split_segment_parameters(url)

528

 

    new_parameters = {}

529

 

    new_parameters.update(existing_parameters)

530

 

    for key, value in parameters.iteritems():

531

 

        if type(key) is not str:

532

 

            raise TypeError("parameter key %r is not a bytestring" % key)

533

 

        if type(value) is not str:

534

 

            raise TypeError("parameter value %r for %s is not a bytestring" %

535

 

                (key, value))

536

 

        if "=" in key:

537

 

            raise errors.InvalidURLJoin("= exists in parameter key", url,

538

 

                parameters)

539

 

        new_parameters[key] = value

540

 

    return join_segment_parameters_raw(base, 

541

 

        *["%s=%s" % item for item in sorted(new_parameters.items())])

542

 

 

543

 

 

544

468

def _win32_strip_local_trailing_slash(url):

545

469

    """Strip slashes after the drive letter"""

546

470

    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:

618

542

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

619

543

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

620

544

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

621

 

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

 

545

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

622

546

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

623

547

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

624

548

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

650

574

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

651

575

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

652

576

 

653

 

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

 

577

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

654

578

    need to stay as escapes are left alone.

655

579

 

656

580

    :param url: A 7-bit ASCII URL

657

581

    :param encoding: The final output encoding

658

582

 

659

 

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

 

583

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

660

584

         specified encoding.

661

585

    """

662

586

    if encoding is None:

763

687

    if len(segments) == 0:

764

688

        return '.'

765

689

    return osutils.pathjoin(*segments)

766

 

 

767

 

 

768

 

 

769

 

def parse_url(url):

770

 

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

771

 

 

772

 

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

773

 

    chars.

774

 

 

775

 

    :param url: an quoted url

776

 

 

777

 

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

778

 

        are unquoted.

779

 

    """

780

 

    if isinstance(url, unicode):

781

 

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

782

 

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

783

 

    (scheme, netloc, path, params,

784

 

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

785

 

    user = password = host = port = None

786

 

    if '@' in netloc:

787

 

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

788

 

        if ':' in user:

789

 

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

790

 

            password = urllib.unquote(password)

791

 

        user = urllib.unquote(user)

792

 

    else:

793

 

        host = netloc

794

 

 

795

 

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

796

 

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

797

 

        try:

798

 

            port = int(port)

799

 

        except ValueError:

800

 

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

801

 

                                    (port, url))

802

 

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

803

 

        host = host[1:-1]

804

 

 

805

 

    host = urllib.unquote(host)

806

 

    path = urllib.unquote(path)

807

 

 

808

 

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

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0