~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

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

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

Show diffs side-by-side

added

removed

bzrlib/urlutils.py

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):

242

278

    # on non-win32 platform

243

279

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

244

280

    #       which actually strips trailing space characters.

245

 

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

 

281

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

246

282

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

247

283

    if path == '/':

248

284

        return 'file:///'

267

303

    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH

268

304

 

269

305

 

270

 

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

 

306

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

271

307

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

272

308

 

273

309

 

303

339

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

304

340

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

305

341

    """

306

 

    scheme_end, path_start = _find_scheme_and_separator(url)

307

 

    if scheme_end is None:

 

342

    m = _url_scheme_re.match(url)

 

343

    if not m:

308

344

        return local_path_to_url(url)

309

 

    prefix = url[:path_start]

310

 

    path = url[path_start:]

 

345

    scheme = m.group('scheme')

 

346

    path = m.group('path')

311

347

    if not isinstance(url, unicode):

312

348

        for c in url:

313

349

            if c not in _url_safe_characters:

314

350

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

315

351

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

316

352

        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)

317

 

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

 

353

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

318

354

 

319

355

    # We have a unicode (hybrid) url

320

356

    path_chars = list(path)

326

362

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

327

363

    path = ''.join(path_chars)

328

364

    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)

329

 

    return str(prefix + path)

 

365

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

330

366

 

331

367

 

332

368

def relative_url(base, other):

433

469

    return url_base + head, tail

434

470

 

435

471

 

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

472

def _win32_strip_local_trailing_slash(url):

509

473

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

510

474

    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:

• Older »

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