that user's delegated patches"""
pass
- def parse(self, dict):
- if self.param not in dict:
+ def _set_key(self, key):
+ raise NotImplementedError
+
+ def parse(self, values):
+ if self.param not in values:
return
- self._set_key(dict[self.param])
+ self._set_key(values[self.param])
def url_without_me(self):
return self.filters.querystring_without_filter(self)
self.person = None
self.person_match = None
- def _set_key(self, str):
+ def _set_key(self, key):
self.person = None
self.person_match = None
submitter_id = None
- str = str.strip()
- if str == '':
+ key = key.strip()
+ if not key:
return
try:
- submitter_id = int(str)
+ submitter_id = int(key)
except ValueError:
pass
- except:
- return
if submitter_id:
- self.person = Person.objects.get(id=int(str))
+ self.person = Person.objects.get(id=submitter_id)
self.applied = True
return
- people = Person.objects.filter(name__icontains=str)
-
- if not people:
- return
-
- self.person_match = str
- self.applied = True
+ people = Person.objects.filter(name__icontains=key)
+ if people:
+ self.person_match = key
+ self.applied = True
def kwargs(self):
if self.person:
self.state = None
self.applied = True
- def _set_key(self, str):
+ def _set_key(self, key):
self.state = None
- if str == self.any_key:
+ if key == self.any_key:
self.applied = False
return
try:
- self.state = State.objects.get(id=int(str))
- except:
+ self.state = State.objects.get(id=int(key))
+ except (ValueError, State.DoesNotExist):
return
self.applied = True
return None
def _form(self):
- str = '<select name="%s" class="form-control">' % self.param
+ out = '<select name="%s" class="form-control">' % self.param
selected = ''
if not self.applied:
selected = 'selected'
- str += '<option %s value="%s">any</option>' % (selected, self.any_key)
+ out += '<option %s value="%s">any</option>' % (selected, self.any_key)
selected = ''
if self.applied and self.state is None:
selected = 'selected'
- str += '<option %s value="">%s</option>' % (
+ out += '<option %s value="">%s</option>' % (
selected, self.action_req_str)
for state in State.objects.all():
if self.state and self.state == state:
selected = ' selected="true"'
- str += '<option value="%d" %s>%s</option>' % (
+ out += '<option value="%d" %s>%s</option>' % (
state.id, selected, state.name)
- str += '</select>'
- return mark_safe(str)
+ out += '</select>'
+ return mark_safe(out)
def form_function(self):
return 'function(form) { return form.x.value }'
self.param = 'q'
self.search = None
- def _set_key(self, str):
- str = str.strip()
- if str == '':
+ def _set_key(self, key):
+ key = key.strip()
+ if not key:
return
- self.search = str
+
+ self.search = key
self.applied = True
def kwargs(self):
None: 'Both'
}
- def _set_key(self, str):
+ def _set_key(self, key):
self.archive_state = False
self.applied = True
for (k, v) in self.param_map.items():
- if str == v:
+ if key == v:
self.archive_state = k
if self.archive_state is None:
self.applied = False
delegate_id = int(key)
except ValueError:
pass
- except:
- return
if delegate_id:
self.delegate = User.objects.get(id=int(key))
def __init__(self, request):
self._filters = [c(self) for c in filterclasses]
- self.dict = request.GET
+ self.values = request.GET
self.project = None
for f in self._filters:
- f.parse(self.dict)
+ f.parse(self.values)
def set_project(self, project):
self.project = project
def querystring(self, remove=None):
params = dict(self.params())
- for (k, v) in self.dict.items():
+ for (k, v) in self.values.items():
if k not in params:
params[k] = v
from django.db import models
from django.utils.encoding import python_2_unicode_compatible
from django.utils.functional import cached_property
-from django.utils.six.moves import filter
from patchwork.fields import HashField
def name(self):
if self.user.first_name or self.user.last_name:
- names = list(filter(
- bool, [self.user.first_name, self.user.last_name]))
- return ' '.join(names)
+ names = [self.user.first_name, self.user.last_name]
+ return ' '.join([x for x in names if x])
return self.user.username
def contributor_projects(self):
return self.date + self.validity > datetime.datetime.now()
def save(self):
- max = 1 << 32
- if self.key == '':
- str = '%s%s%d' % (self.user, self.email, random.randint(0, max))
- self.key = self._meta.get_field('key').construct(str).hexdigest()
+ limit = 1 << 32
+ if not self.key:
+ key = '%s%s%d' % (self.user, self.email, random.randint(0, limit))
+ self.key = self._meta.get_field('key').construct(key).hexdigest()
super(EmailConfirmation, self).save()
from django.conf import settings
from django.core import paginator
-from django.utils.six.moves import range
DEFAULT_ITEMS_PER_PAGE = 100
from django.contrib.auth.models import User
from django.utils import six
-from django.utils.six.moves import map
from patchwork.models import (Patch, Project, Person, Comment, State,
DelegationRule, Submission, CoverLetter,
LOGGER = logging.getLogger(__name__)
-def normalise_space(str):
+def normalise_space(value):
whitespace_re = re.compile(r'\s+')
- return whitespace_re.sub(' ', str).strip()
+ return whitespace_re.sub(' ', value).strip()
def clean_header(header):
return frag_str.decode()
return frag_str
- fragments = list(map(decode, decode_header(header)))
+ fragments = [decode(x) for x in decode_header(header)]
return normalise_space(u' '.join(fragments))
return 1
return int(x)
- lc = list(map(fn, match.groups()))
+ lc = [fn(x) for x in match.groups()]
state = 4
patchbuf += buf + line
view_name = template.Variable('list_view.view').resolve(context)
kwargs = template.Variable('list_view.view_params').resolve(context)
- str = None
+ path = None
try:
- str = reverse(view_name, args=[], kwargs=kwargs)
+ path = reverse(view_name, args=[], kwargs=kwargs)
except NoReverseMatch:
try:
project_name = settings.SETTINGS_MODULE.split('.')[0]
- str = reverse(project_name + '.' + view_name,
- args=[], kwargs=kwargs)
+ path = reverse(project_name + '.' + view_name,
+ args=[], kwargs=kwargs)
except NoReverseMatch:
raise
- if str is None:
+ if path is None:
return ''
params = []
params[smart_str(k, 'ascii')] = v.resolve(context)
if not params:
- return str
+ return path
- return str + '?' + '&'.join(
+ return path + '?' + '&'.join(
['%s=%s' % (k, escape(v)) for (k, v) in list(params.items())])
url = reverse('patch-list',
kwargs={'project_id': project.linkname})
-
str = '<a href="%s?%s=%s">%s</a>' % (
+
out = '<a href="%s?%s=%s">%s</a>' % (
url, SubmitterFilter.param, escape(person.id), linktext)
- return mark_safe(str)
+ return mark_safe(out)
from django import template
from django.utils.html import escape
from django.utils.safestring import mark_safe
-from django.utils.six.moves import map
register = template.Library()
-def _compile(t):
- (r, str) = t
- return (re.compile(r, re.M | re.I), str)
+def _compile(value):
+ regex, cls = value
+ return re.compile(regex, re.M | re.I), cls
-_patch_span_res = list(map(_compile, [
+_patch_span_res = [_compile(x) for x in [
(r'^(Index:?|diff|\-\-\-|\+\+\+|\*\*\*) .*$', 'p_header'),
(r'^\+.*$', 'p_add'),
(r'^-.*$', 'p_del'),
(r'^!.*$', 'p_mod'),
-]))
+]]
-_patch_chunk_re = \
- re.compile(r'^(@@ \-\d+(?:,\d+)? \+\d+(?:,\d+)? @@)(.*)$', re.M | re.I)
+_patch_chunk_re = re.compile(
+ r'^(@@ \-\d+(?:,\d+)? \+\d+(?:,\d+)? @@)(.*)$', re.M | re.I)
-_comment_span_res = list(map(_compile, [
+_comment_span_res = [_compile(x) for x in [
(r'^\s*Signed-off-by: .*$', 'signed-off-by'),
(r'^\s*Acked-by: .*$', 'acked-by'),
(r'^\s*Nacked-by: .*$', 'nacked-by'),
(r'^\s*Reviewed-by: .*$', 'reviewed-by'),
(r'^\s*From: .*$', 'from'),
(r'^\s*>.*$', 'quote'),
-]))
+]]
_span = '<span class="%s">%s</span>'
def patchsyntax(patch):
diff = escape(patch.diff).replace('\r\n', '\n')
- for (r, cls) in _patch_span_res:
- diff = r.sub(lambda x: _span % (cls, x.group(0)), diff)
+ for (regex, cls) in _patch_span_res:
+ diff = regex.sub(lambda x: _span % (cls, x.group(0)), diff)
diff = _patch_chunk_re.sub(
lambda x:
urlpatterns = [
url(r'^admin/', include(admin.site.urls)),
- url(r'^$', project_views.list, name='project-list'),
- url(r'^project/(?P<project_id>[^/]+)/list/$', patch_views.list,
+ url(r'^$', project_views.projects, name='project-list'),
+ url(r'^project/(?P<project_id>[^/]+)/list/$', patch_views.patches,
name='patch-list'),
url(r'^project/(?P<project_id>[^/]+)/bundles/$', bundle_views.bundles,
name='bundle-list'),
url(r'^cover/(?P<cover_id>\d+)/$', cover_views.cover,
name='cover-detail'),
-
# logged-in user stuff
url(r'^user/$', user_views.profile, name='user-profile'),
url(r'^user/todo/$', user_views.todo_lists,
url(r'^mail/optin/$', mail_views.optin, name='mail-optin'),
# help!
- url(r'^help/(?P<path>.*)$', help_views.help, name='help'),
+ url(r'^help/(?P<path>.*)$', help_views.detail, name='help'),
]
if 'debug_toolbar' in settings.INSTALLED_APPS:
else:
patch_ids = get_patch_ids(request.POST)
- for id in patch_ids:
+ for patch_id in patch_ids:
try:
- patch = Patch.objects.get(id=id)
+ patch = Patch.objects.get(id=patch_id)
bundle.append_patch(patch)
except:
pass
help_pages['pwclient/'] = 'pwclient.html'
-def help(request, path):
+def detail(request, path):
if path in help_pages:
return render(request,
'patchwork/help/' + help_pages[path])
return render(request, 'patchwork/submission.html', context)
+def patches(request, project_id):
+ project = get_object_or_404(Project, linkname=project_id)
+ context = generic_list(request, project, 'patch-list',
+ view_args={'project_id': project.linkname})
+ return render(request, 'patchwork/list.html', context)
+
+
def content(request, patch_id):
patch = get_object_or_404(Patch, id=patch_id)
response = HttpResponse(content_type="text/x-patch")
response['Content-Disposition'] = 'attachment; filename=' + \
patch.filename().replace(';', '').replace('\n', '')
return response
-
-
-def list(request, project_id):
- project = get_object_or_404(Project, linkname=project_id)
- context = generic_list(request, project, 'patch-list',
- view_args={'project_id': project.linkname})
- return render(request, 'patchwork/list.html', context)
from patchwork.models import Project
-def list(request):
+def projects(request):
projects = Project.objects.all()
if projects.count() == 1:
return render(request, 'patchwork/projects.html', context)
-# TODO(stephenfin): Consistently rename these as list and detail
def project(request, project_id):
project = get_object_or_404(Project, linkname=project_id)
@xmlrpc_method()
-def patch_get_by_hash(hash):
+def patch_get_by_hash(hash): # noqa
"""Get a patch by its hash.
Retrieve a patch matching a given patch hash, if any exists.
projects / thirdparty / patchwork.git / commitdiff
