/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

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

• reverse the comparison (1996.1.26 to 2425.1.1)
• stop comparing with revision 2425.1.1

Show diffs side-by-side

added

removed

bzrlib/urlutils.py

1

1

# Bazaar -- distributed version control

2

2

#

3

 

# Copyright (C) 2006 Canonical Ltd

 

3

# Copyright (C) 2006 by Canonical Ltd

4

4

#

5

5

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

6

6

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

19

19

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

20

20

 

21

21

import os

 

22

from posixpath import split as _posix_split, normpath as _posix_normpath

22

23

import re

23

24

import sys

24

 

 

25

 

from bzrlib.lazy_import import lazy_import

26

 

lazy_import(globals(), """

27

 

from posixpath import split as _posix_split, normpath as _posix_normpath

28

25

import urllib

29

26

 

30

 

from bzrlib import (

31

 

    errors,

32

 

    osutils,

33

 

    )

34

 

""")

 

27

import bzrlib.errors as errors

 

28

import bzrlib.osutils

35

29

 

36

30

 

37

31

def basename(url, exclude_trailing_slash=True):

81

75

 

82

76

    base = local_path_from_url(base)

83

77

    path = local_path_from_url(path)

84

 

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

 

78

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

85

79

 

86

80

 

87

81

def _find_scheme_and_separator(url):

117

111

        join('http://foo', 'bar') => 'http://foo/bar'

118

112

        join('http://foo', 'bar', '../baz') => 'http://foo/baz'

119

113

    """

120

 

    if not args:

121

 

        return base

122

 

    match = _url_scheme_re.match(base)

 

114

    m = _url_scheme_re.match(base)

123

115

    scheme = None

124

 

    if match:

125

 

        scheme = match.group('scheme')

126

 

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

 

116

    if m:

 

117

        scheme = m.group('scheme')

 

118

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

127

119

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

128

120

            # Strip off a trailing slash

129

121

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

132

124

    else:

133

125

        path = base.split('/')

134

126

 

135

 

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

136

 

        host = path[:1]

137

 

        # the path should be represented as an abs path.

138

 

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

139

 

        remove_root = True

140

 

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

141

 

    else:

142

 

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

143

 

        # relative url fragment.

144

 

        host = []

145

 

        remove_root = False

146

 

 

147

127

    for arg in args:

148

 

        match = _url_scheme_re.match(arg)

149

 

        if match:

 

128

        m = _url_scheme_re.match(arg)

 

129

        if m:

150

130

            # Absolute URL

151

 

            scheme = match.group('scheme')

152

 

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

153

 

            # be rather strange.

154

 

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

155

 

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

156

 

            # any previous values.

157

 

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

158

 

            # manipulation code needs some cleaning up.

159

 

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

160

 

                host = path[:1]

161

 

                path = path[1:]

162

 

                # url scheme implies absolute path.

163

 

                path = [''] + path

164

 

            else:

165

 

                # no url scheme we take the path as is.

166

 

                host = []

 

131

            scheme = m.group('scheme')

 

132

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

167

133

        else:

168

 

            path = '/'.join(path)

169

 

            path = joinpath(path, arg)

170

 

            path = path.split('/')

171

 

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

172

 

        del path[0]

173

 

    if host:

174

 

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

175

 

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

176

 

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

177

 

            del path[0]

178

 

        path = host + path

 

134

            for chunk in arg.split('/'):

 

135

                if chunk == '.':

 

136

                    continue

 

137

                elif chunk == '..':

 

138

                    if len(path) >= 2:

 

139

                        # Don't pop off the host portion

 

140

                        path.pop()

 

141

                    else:

 

142

                        raise errors.InvalidURLJoin('Cannot go above root',

 

143

                                base, args)

 

144

                else:

 

145

                    path.append(chunk)

179

146

 

180

147

    if scheme is None:

181

148

        return '/'.join(path)

182

149

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

183

150

 

184

151

 

185

 

def joinpath(base, *args):

186

 

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

187

 

    

188

 

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

189

 

 

190

 

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

191

 

    path handling logic that already exists in some Transport implementations.

192

 

    We really should try to have exactly one place in the code base responsible

193

 

    for combining paths of URLs.

194

 

    """

195

 

    path = base.split('/')

196

 

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

197

 

        #If the path ends in a trailing /, remove it.

198

 

        path.pop()

199

 

    for arg in args:

200

 

        if arg.startswith('/'):

201

 

            path = []

202

 

        for chunk in arg.split('/'):

203

 

            if chunk == '.':

204

 

                continue

205

 

            elif chunk == '..':

206

 

                if path == ['']:

207

 

                    raise errors.InvalidURLJoin('Cannot go above root',

208

 

                            base, args)

209

 

                path.pop()

210

 

            else:

211

 

                path.append(chunk)

212

 

    if path == ['']:

213

 

        return '/'

214

 

    else:

215

 

        return '/'.join(path)

216

 

 

217

 

 

218

152

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

219

153

def _posix_local_path_from_url(url):

220

154

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

232

166

    # importing directly from posixpath allows us to test this 

233

167

    # on non-posix platforms

234

168

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

235

 

        osutils._posix_abspath(path)))

 

169

        bzrlib.osutils._posix_abspath(path)))

236

170

 

237

171

 

238

172

def _win32_local_path_from_url(url):

239

173

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

240

 

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

241

 

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

242

 

                                     'UNC path urls must start with file://')

 

174

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

 

175

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

243

176

    # We strip off all 3 slashes

244

 

    win32_url = url[len('file:'):]

245

 

    # check for UNC path: //HOST/path

246

 

    if not win32_url.startswith('///'):

247

 

        if (win32_url[2] == '/'

248

 

            or win32_url[3] in '|:'):

249

 

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

250

 

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

251

 

        return unescape(win32_url)

252

 

    # usual local path with drive letter

253

 

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

 

177

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

 

178

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

254

179

                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')

255

 

        or win32_url[4] not in  '|:'

256

 

        or win32_url[5] != '/'):

 

180

        or win32_url[1] not in  '|:'

 

181

        or win32_url[2] != '/'):

257

182

        raise errors.InvalidURL(url, 'Win32 file urls start with'

258

183

                ' file:///x:/, where x is a valid drive letter')

259

 

    return win32_url[3].upper() + u':' + unescape(win32_url[5:])

 

184

    return win32_url[0].upper() + u':' + unescape(win32_url[2:])

260

185

 

261

186

 

262

187

def _win32_local_path_to_url(path):

270

195

    #       which actually strips trailing space characters.

271

196

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

272

197

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

273

 

    win32_path = osutils._win32_abspath(path)

274

 

    # check for UNC path \\HOST\path

275

 

    if win32_path.startswith('//'):

276

 

        return 'file:' + escape(win32_path)

 

198

    win32_path = bzrlib.osutils._nt_normpath(

 

199

        bzrlib.osutils._win32_abspath(path)).replace('\\', '/')

277

200

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

278

201

 

279

202

 

328

251

        if path[i] not in _url_safe_characters:

329

252

            chars = path[i].encode('utf-8')

330

253

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

331

 

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

 

254

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

332

255

 

333

256

 

334

257

def relative_url(base, other):

462

385

    if not url.endswith('/'):

463

386

        # Nothing to do

464

387

        return url

465

 

    if sys.platform == 'win32' and url.startswith('file://'):

 

388

    if sys.platform == 'win32' and url.startswith('file:///'):

466

389

        return _win32_strip_local_trailing_slash(url)

467

390

 

468

391

    scheme_loc, first_path_slash = _find_scheme_and_separator(url)

515

438

_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)

516

439

 

517

440

# These characters should not be escaped

518

 

_url_safe_characters = set(

519

 

   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha

520

 

   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha

521

 

   "0123456789" # Numbers

522

 

   "_.-!~*'()"  # Unreserved characters

523

 

   "/;?:@&=+$," # Reserved characters

524

 

   "%#"         # Extra reserved characters

525

 

)

 

441

_url_safe_characters = set('abcdefghijklmnopqrstuvwxyz'

 

442

                        'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

 

443

                        '0123456789' '_.-/'

 

444

                        ';?:@&=+$,%#')

 

445

 

526

446

 

527

447

def unescape_for_display(url, encoding):

528

448

    """Decode what you can for a URL, so that we get a nice looking path.

• Older »

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