~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

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

• reverse the comparison (4634.146.5 to 5401)
• stop comparing with revision 5401

Show diffs side-by-side

added

removed

bzrlib/urlutils.py

1

 

# Copyright (C) 2006-2010 Canonical Ltd

 

1

# Copyright (C) 2006, 2008 Canonical Ltd

2

2

#

3

3

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

4

4

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

101

101

    first_path_slash = path.find('/')

102

102

    if first_path_slash == -1:

103

103

        return len(scheme), None

104

 

    return len(scheme), first_path_slash+m.start('path')

105

 

 

106

 

 

107

 

def is_url(url):

108

 

    """Tests whether a URL is in actual fact a URL."""

109

 

    return _url_scheme_re.match(url) is not None

 

104

    return len(scheme), first_path_slash+len(scheme)+3

110

105

 

111

106

 

112

107

def join(base, *args):

123

118

    """

124

119

    if not args:

125

120

        return base

126

 

    scheme_end, path_start = _find_scheme_and_separator(base)

127

 

    if scheme_end is None and path_start is None:

128

 

        path_start = 0

129

 

    elif path_start is None:

130

 

        path_start = len(base)

131

 

    path = base[path_start:]

 

121

    match = _url_scheme_re.match(base)

 

122

    scheme = None

 

123

    if match:

 

124

        scheme = match.group('scheme')

 

125

        path = match.group('path').split('/')

 

126

        if path[-1:] == ['']:

 

127

            # Strip off a trailing slash

 

128

            # This helps both when we are at the root, and when

 

129

            # 'base' has an extra slash at the end

 

130

            path = path[:-1]

 

131

    else:

 

132

        path = base.split('/')

 

133

 

 

134

    if scheme is not None and len(path) >= 1:

 

135

        host = path[:1]

 

136

        # the path should be represented as an abs path.

 

137

        # we know this must be absolute because of the presence of a URL scheme.

 

138

        remove_root = True

 

139

        path = [''] + path[1:]

 

140

    else:

 

141

        # create an empty host, but dont alter the path - this might be a

 

142

        # relative url fragment.

 

143

        host = []

 

144

        remove_root = False

 

145

 

132

146

    for arg in args:

133

 

        arg_scheme_end, arg_path_start = _find_scheme_and_separator(arg)

134

 

        if arg_scheme_end is None and arg_path_start is None:

135

 

            arg_path_start = 0

136

 

        elif arg_path_start is None:

137

 

            arg_path_start = len(arg)

138

 

        if arg_scheme_end is not None:

139

 

            base = arg

140

 

            path = arg[arg_path_start:]

141

 

            scheme_end = arg_scheme_end

142

 

            path_start = arg_path_start

 

147

        match = _url_scheme_re.match(arg)

 

148

        if match:

 

149

            # Absolute URL

 

150

            scheme = match.group('scheme')

 

151

            # this skips .. normalisation, making http://host/../../..

 

152

            # be rather strange.

 

153

            path = match.group('path').split('/')

 

154

            # set the host and path according to new absolute URL, discarding

 

155

            # any previous values.

 

156

            # XXX: duplicates mess from earlier in this function.  This URL

 

157

            # manipulation code needs some cleaning up.

 

158

            if scheme is not None and len(path) >= 1:

 

159

                host = path[:1]

 

160

                path = path[1:]

 

161

                # url scheme implies absolute path.

 

162

                path = [''] + path

 

163

            else:

 

164

                # no url scheme we take the path as is.

 

165

                host = []

143

166

        else:

 

167

            path = '/'.join(path)

144

168

            path = joinpath(path, arg)

145

 

    return base[:path_start] + path

 

169

            path = path.split('/')

 

170

    if remove_root and path[0:1] == ['']:

 

171

        del path[0]

 

172

    if host:

 

173

        # Remove the leading slash from the path, so long as it isn't also the

 

174

        # trailing slash, which we want to keep if present.

 

175

        if path and path[0] == '' and len(path) > 1:

 

176

            del path[0]

 

177

        path = host + path

 

178

 

 

179

    if scheme is None:

 

180

        return '/'.join(path)

 

181

    return scheme + '://' + '/'.join(path)

146

182

 

147

183

 

148

184

def joinpath(base, *args):

181

217

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

182

218

def _posix_local_path_from_url(url):

183

219

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

184

 

    file_localhost_prefix = 'file://localhost/'

185

 

    if url.startswith(file_localhost_prefix):

186

 

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

187

 

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

188

 

        raise errors.InvalidURL(

189

 

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

190

 

    else:

191

 

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

 

220

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

 

221

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

192

222

    # We only strip off 2 slashes

193

 

    return unescape(path)

 

223

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

194

224

 

195

225

 

196

226

def _posix_local_path_to_url(path):

242

272

    # on non-win32 platform

243

273

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

244

274

    #       which actually strips trailing space characters.

245

 

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

 

275

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

246

276

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

247

277

    if path == '/':

248

278

        return 'file:///'

267

297

    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH

268

298

 

269

299

 

270

 

_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')

 

300

_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')

271

301

_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')

272

302

 

273

303

 

303

333

    :param url: Either a hybrid URL or a local path

304

334

    :return: A normalized URL which only includes 7-bit ASCII characters.

305

335

    """

306

 

    scheme_end, path_start = _find_scheme_and_separator(url)

307

 

    if scheme_end is None:

 

336

    m = _url_scheme_re.match(url)

 

337

    if not m:

308

338

        return local_path_to_url(url)

309

 

    prefix = url[:path_start]

310

 

    path = url[path_start:]

 

339

    scheme = m.group('scheme')

 

340

    path = m.group('path')

311

341

    if not isinstance(url, unicode):

312

342

        for c in url:

313

343

            if c not in _url_safe_characters:

314

344

                raise errors.InvalidURL(url, 'URLs can only contain specific'

315

345

                                            ' safe characters (not %r)' % c)

316

346

        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)

317

 

        return str(prefix + ''.join(path))

 

347

        return str(scheme + '://' + ''.join(path))

318

348

 

319

349

    # We have a unicode (hybrid) url

320

350

    path_chars = list(path)

326

356

                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])

327

357

    path = ''.join(path_chars)

328

358

    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)

329

 

    return str(prefix + path)

 

359

    return str(scheme + '://' + path)

330

360

 

331

361

 

332

362

def relative_url(base, other):

433

463

    return url_base + head, tail

434

464

 

435

465

 

436

 

def split_segment_parameters_raw(url):

437

 

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

438

 

 

439

 

    :param url: A relative or absolute URL

440

 

    :return: (url, subsegments)

441

 

    """

442

 

    (parent_url, child_dir) = split(url)

443

 

    subsegments = child_dir.split(",")

444

 

    if len(subsegments) == 1:

445

 

        return (url, [])

446

 

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

447

 

 

448

 

 

449

 

def split_segment_parameters(url):

450

 

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

451

 

 

452

 

    :param url: A relative or absolute URL

453

 

    :return: (url, segment_parameters)

454

 

    """

455

 

    (base_url, subsegments) = split_segment_parameters_raw(url)

456

 

    parameters = {}

457

 

    for subsegment in subsegments:

458

 

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

459

 

        parameters[key] = value

460

 

    return (base_url, parameters)

461

 

 

462

 

 

463

 

def join_segment_parameters_raw(base, *subsegments):

464

 

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

465

 

 

466

 

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

467

 

    base URL. The subsegments should be bytestrings.

468

 

 

469

 

    :note: You probably want to use join_segment_parameters instead.

470

 

    """

471

 

    if not subsegments:

472

 

        return base

473

 

    for subsegment in subsegments:

474

 

        if type(subsegment) is not str:

475

 

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

476

 

        if "," in subsegment:

477

 

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

478

 

                                        base, subsegments)

479

 

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

480

 

 

481

 

 

482

 

def join_segment_parameters(url, parameters):

483

 

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

484

 

 

485

 

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

486

 

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

487

 

 

488

 

    :param url: A URL, as string

489

 

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

490

 

    """

491

 

    (base, existing_parameters) = split_segment_parameters(url)

492

 

    new_parameters = {}

493

 

    new_parameters.update(existing_parameters)

494

 

    for key, value in parameters.iteritems():

495

 

        if type(key) is not str:

496

 

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

497

 

        if type(value) is not str:

498

 

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

499

 

                (key, value))

500

 

        if "=" in key:

501

 

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

502

 

                parameters)

503

 

        new_parameters[key] = value

504

 

    return join_segment_parameters_raw(base, 

505

 

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

506

 

 

507

 

 

508

466

def _win32_strip_local_trailing_slash(url):

509

467

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

510

468

    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:

• Older »

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