← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to ivle/util.py

  • Committer: Matt Giuca
  • Date: 2010-02-23 05:27:07 UTC
  • Revision ID: matt.giuca@gmail.com-20100223052707-3a76wo23r2z503t8
https://launchpad.net/bugs/526161
browser.js: Adjusted condition for enabling "Commit" action; now allowed if
    no files are selected AND current directory is versioned (as well as if
    all selected files are versioned). Committing with 0 files selected will
    commit the current directory.
ivle.fileservice_lib.action: Fixed to allow commit to contain 0 paths. This
    will commit the current directory instead.
This fixes Launchpad bug #526161.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/util.py
22
22
# Contains common utility functions.
23
23
 
24
24
import os
25
 
import datetime
26
 
 
27
 
import ivle.conf
 
25
import sys
 
26
import stat
28
27
 
29
28
class IVLEError(Exception):
30
 
    """
31
 
    This is the "standard" exception class for IVLE errors.
32
 
    It is the ONLY exception which should propagate to the top - it will then
33
 
    be displayed to the user as an HTTP error with the given code.
34
 
 
35
 
    All other exceptions are considered IVLE bugs and should not occur
36
 
    (they will display a traceback).
37
 
 
38
 
    This error should not be raised directly. Call req.throw_error.
39
 
    """
 
29
    """Legacy general IVLE exception.
 
30
 
 
31
    This is the old "standard" exception class for IVLE errors. It is only
 
32
    used in fileservice, and should not be used in any new code.
 
33
    """
 
34
 
 
35
    message = None
 
36
 
40
37
    def __init__(self, httpcode, message=None):
41
38
        self.httpcode = httpcode
42
39
        self.message = message
43
40
        self.args = (httpcode, message)
44
41
 
45
42
class IVLEJailError(Exception):
46
 
    """
 
43
    """Exception proxying an in-jail error.
 
44
 
47
45
    This exception indicates an error that occurred inside an IVLE CGI script
48
46
    inside the jail. It should never be raised directly - only by the 
49
47
    interpreter.
66
64
    def __repr__(self):
67
65
        return "<Fake %s %s>"%(self.type, self.name)
68
66
 
69
 
def make_path(path):
70
 
    """Given a path relative to the IVLE root, makes the path relative to the
71
 
    site root using ivle.conf.root_dir. This path can be used in URLs sent to
72
 
    the client."""
73
 
    return os.path.join(ivle.conf.root_dir, path)
74
 
 
75
67
def split_path(path):
76
68
    """Given a path, returns a tuple consisting of the top-level directory in
77
69
    the path, and the rest of the path. Note that both items in the tuple will
107
99
    else:
108
100
        return tuple(splitpath)
109
101
 
 
102
def relpath(path, start=os.path.curdir):
 
103
    """Return a relative version of a path.
 
104
    XXX Backported from Python 2.6 posixpath.py.
 
105
    """
 
106
 
 
107
    if not path:
 
108
        raise ValueError("no path specified")
 
109
 
 
110
    start_list = os.path.abspath(start).split(os.path.sep)
 
111
    path_list = os.path.abspath(path).split(os.path.sep)
 
112
 
 
113
    # Work out how much of the filepath is shared by start and path.
 
114
    i = len(os.path.commonprefix([start_list, path_list]))
 
115
 
 
116
    rel_list = [os.path.pardir] * (len(start_list)-i) + path_list[i:]
 
117
    if not rel_list:
 
118
        return os.path.curdir
 
119
    return os.path.join(*rel_list)
 
120
 
110
121
def incomplete_utf8_sequence(byteseq):
111
 
    """
112
 
    str -> int
 
122
    """Calculate the completeness of a UTF-8 encoded string.
 
123
 
113
124
    Given a UTF-8-encoded byte sequence (str), returns the number of bytes at
114
125
    the end of the string which comprise an incomplete UTF-8 character
115
126
    sequence.
187
198
        return count
188
199
 
189
200
def object_to_dict(attrnames, obj):
190
 
    """
191
 
    Convert an object into a dictionary. This takes a shallow copy of the
192
 
    object.
193
 
    attrnames: Set (or iterable) of names of attributes to be copied into the
194
 
        dictionary. (We don't auto-lookup, because this function needs to be
195
 
        used on magical objects).
 
201
    """Convert an object into a dictionary.
 
202
 
 
203
    This takes a shallow copy of the object.
 
204
 
 
205
    @param attrnames: Set (or iterable) of names of attributes to be copied
 
206
                      into the dictionary. (We don't auto-lookup, because this
 
207
                      function needs to be used on magical objects).
196
208
    """
197
209
    return dict((k, getattr(obj, k))
198
210
        for k in attrnames if not k.startswith('_'))
 
211
 
 
212
def safe_rmtree(path, ignore_errors=False, onerror=None):
 
213
    """Recursively delete a directory tree.
 
214
 
 
215
    Copied from shutil.rmtree from Python 2.6, which does not follow symbolic
 
216
    links (it is otherwise unsafe to call as root on untrusted directories; do
 
217
    not use shutil.rmtree in this case, as you may be running Python 2.5).
 
218
 
 
219
    If ignore_errors is set, errors are ignored; otherwise, if onerror
 
220
    is set, it is called to handle the error with arguments (func,
 
221
    path, exc_info) where func is os.listdir, os.remove, or os.rmdir;
 
222
    path is the argument to that function that caused it to fail; and
 
223
    exc_info is a tuple returned by sys.exc_info().  If ignore_errors
 
224
    is false and onerror is None, an exception is raised.
 
225
 
 
226
    """
 
227
    if ignore_errors:
 
228
        def onerror(*args):
 
229
            pass
 
230
    elif onerror is None:
 
231
        def onerror(*args):
 
232
            raise
 
233
    try:
 
234
        if os.path.islink(path):
 
235
            # symlinks to directories are forbidden, see bug #1669
 
236
            raise OSError("Cannot call safe_rmtree on a symbolic link")
 
237
    except OSError:
 
238
        onerror(os.path.islink, path, sys.exc_info())
 
239
        # can't continue even if onerror hook returns
 
240
        return
 
241
    names = []
 
242
    try:
 
243
        names = os.listdir(path)
 
244
    except os.error, err:
 
245
        onerror(os.listdir, path, sys.exc_info())
 
246
    for name in names:
 
247
        fullname = os.path.join(path, name)
 
248
        try:
 
249
            mode = os.lstat(fullname).st_mode
 
250
        except os.error:
 
251
            mode = 0
 
252
        if stat.S_ISDIR(mode):
 
253
            safe_rmtree(fullname, ignore_errors, onerror)
 
254
        else:
 
255
            try:
 
256
                os.remove(fullname)
 
257
            except os.error, err:
 
258
                onerror(os.remove, fullname, sys.exc_info())
 
259
    try:
 
260
        os.rmdir(path)
 
261
    except os.error:
 
262
        onerror(os.rmdir, path, sys.exc_info())
 
263
 
 
264
def format_submission_principal(user, principal):
 
265
    """Render a list of users to fit in the offering project listing.
 
266
 
 
267
    Given a user and a list of submitters, returns 'solo' if the
 
268
    only submitter is the user, or a string of the form
 
269
    'with A, B and C' if there are any other submitters.
 
270
 
 
271
    If submitters is None, we assume that the list of members could
 
272
    not be determined, so we just return 'group'.
 
273
    """
 
274
    if principal is None:
 
275
        return 'group'
 
276
 
 
277
    if principal is user:
 
278
        return 'solo'
 
279
 
 
280
    display_names = sorted(
 
281
        member.display_name for member in principal.members
 
282
        if member is not user)
 
283
 
 
284
    if len(display_names) == 0:
 
285
        return 'solo (%s)' % principal.name
 
286
    elif len(display_names) == 1:
 
287
        return 'with %s (%s)' % (display_names[0], principal.name)
 
288
    elif len(display_names) > 5:
 
289
        return 'with %d others (%s)' % (len(display_names), principal.name)
 
290
    else:
 
291
        return 'with %s and %s (%s)' % (', '.join(display_names[:-1]),
 
292
                                        display_names[-1], principal.name)