Small code cleanups

boards/authors.py

@@ -1,31 +1,35
+__author__ = 'neko259'
+
 from django.utils.translation import ugettext_lazy as _
 
-__author__ = 'neko259'
+ATTR_ROLES = 'roles'
+ATTR_CONTACTS = 'contacts'
+ATTR_NAME = 'name'
 
 ROLE_AUTHOR = _('author')
 ROLE_DEVELOPER = _('developer')
 ROLE_JS_DEV = _('javascript developer')
 ROLE_DESIGNER = _('designer')
 
 authors = {
     'neko259': {
-        'name': 'Pavel Ryapolov',
-        'contacts': ['[e-mail]'],
-        'roles': [ROLE_AUTHOR, ROLE_DEVELOPER],
+        ATTR_NAME: 'Pavel Ryapolov',
+        ATTR_CONTACTS: ['[e-mail]'],
+        ATTR_ROLES: [ROLE_AUTHOR, ROLE_DEVELOPER],
     },
     'ilyas': {
-        'name': 'Ilyas Babayev',
-        'contacts': ['[e-mail]'],
-        'roles': [ROLE_AUTHOR, ROLE_DEVELOPER],
+        ATTR_NAME: 'Ilyas Babayev',
+        ATTR_CONTACTS: ['[e-mail]'],
+        ATTR_ROLES: [ROLE_AUTHOR, ROLE_DEVELOPER],
     },
     'ritsufag': {
-        'name': 'Aiko Kirino',
-        'contacts': ['[e-mail]'],
-        'roles': [ROLE_JS_DEV, ROLE_DESIGNER],
+        ATTR_NAME: 'Aiko Kirino',
+        ATTR_CONTACTS: ['[e-mail]'],
+        ATTR_ROLES: [ROLE_JS_DEV, ROLE_DESIGNER],
     },
     'Tenno Seremel': {
-        'name': 'anonymous',
-        'contacts': ['[e-mail]'],
-        'roles': [ROLE_JS_DEV, ROLE_DESIGNER],
+        ATTR_NAME: 'anonymous',
+        ATTR_CONTACTS: ['[e-mail]'],
+        ATTR_ROLES: [ROLE_JS_DEV, ROLE_DESIGNER],
     },
 }
  No newline at end of file

boards/context_processors.py

@@ -1,30 +1,39
+__author__ = 'neko259'
+
 from boards import utils, settings
 from boards.models import Post
 from boards.models.post import SETTING_MODERATE
 
-__author__ = 'neko259'
+CONTEXT_SITE_NAME = 'site_name'
+CONTEXT_VERSION = 'version'
+CONTEXT_MODERATOR = 'moderator'
+CONTEXT_THEME_CSS = 'theme_css'
+CONTEXT_THEME = 'theme'
+CONTEXT_PPD = 'posts_per_day'
+CONTEXT_TAGS = 'tags'
+CONTEXT_USER = 'user'
 
 
 def user_and_ui_processor(request):
     context = {}
 
     user = utils.get_user(request)
-    context['user'] = user
-    context['tags'] = user.fav_tags.all()
-    context['posts_per_day'] = float(Post.objects.get_posts_per_day())
+    context[CONTEXT_USER] = user
+    context[CONTEXT_TAGS] = user.fav_tags.all()
+    context[CONTEXT_PPD] = float(Post.objects.get_posts_per_day())
 
     theme = utils.get_theme(request, user)
-    context['theme'] = theme
-    context['theme_css'] = 'css/' + theme + '/base_page.css'
+    context[CONTEXT_THEME] = theme
+    context[CONTEXT_THEME_CSS] = 'css/' + theme + '/base_page.css'
 
     # This shows the moderator panel
     moderate = user.get_setting(SETTING_MODERATE)
     if moderate == 'True':
-        context['moderator'] = user.is_moderator()
+        context[CONTEXT_MODERATOR] = user.is_moderator()
     else:
-        context['moderator'] = False
+        context[CONTEXT_MODERATOR] = False
 
-    context['version'] = settings.VERSION
-    context['site_name'] = settings.SITE_NAME
+    context[CONTEXT_VERSION] = settings.VERSION
+    context[CONTEXT_SITE_NAME] = settings.SITE_NAME
 
     return context
  No newline at end of file

boards/forms.py

@@ -1,355 +1,356
 import re
 import time
 import hashlib
 
 from captcha.fields import CaptchaField
 from django import forms
 from django.forms.util import ErrorList
 from django.utils.translation import ugettext_lazy as _
 
 from boards.mdx_neboard import formatters
 from boards.models.post import TITLE_MAX_LENGTH
 from boards.models import User, PostImage
 from neboard import settings
 from boards import utils
 import boards.settings as board_settings
 
 VETERAN_POSTING_DELAY = 5
 
 ATTRIBUTE_PLACEHOLDER = 'placeholder'
 
 LAST_POST_TIME = 'last_post_time'
 LAST_LOGIN_TIME = 'last_login_time'
 TEXT_PLACEHOLDER = _('''Type message here. You can reply to message >>123 like
  this. 2 new lines are required to start new paragraph.''')
 TAGS_PLACEHOLDER = _('tag1 several_words_tag')
 
 ERROR_IMAGE_DUPLICATE = _('Such image was already posted')
 
 LABEL_TITLE = _('Title')
 LABEL_TEXT = _('Text')
 LABEL_TAG = _('Tag')
 LABEL_SEARCH = _('Search')
 
 TAG_MAX_LENGTH = 20
 
 REGEX_TAG = ur'^[\w\d]+$'
 
 
 class FormatPanel(forms.Textarea):
     def render(self, name, value, attrs=None):
         output = '<div id="mark-panel">'
         for formatter in formatters:
             output += u'<span class="mark_btn"' + \
                       u' onClick="addMarkToMsg(\'' + formatter.format_left + \
                       '\', \'' + formatter.format_right + '\')">' + \
                       formatter.preview_left + formatter.name + \
                       formatter.preview_right + u'</span>'
 
         output += '</div>'
         output += super(FormatPanel, self).render(name, value, attrs=None)
 
         return output
 
 
 class PlainErrorList(ErrorList):
     def __unicode__(self):
         return self.as_text()
 
     def as_text(self):
         return ''.join([u'(!) %s ' % e for e in self])
 
 
 class NeboardForm(forms.Form):
 
     def as_div(self):
         """
         Returns this form rendered as HTML <as_div>s.
         """
 
         return self._html_output(
             # TODO Do not show hidden rows in the list here
             normal_row='<div class="form-row"><div class="form-label">'
                        '%(label)s'
                        '</div></div>'
                        '<div class="form-row"><div class="form-input">'
                        '%(field)s'
                        '</div></div>'
                        '<div class="form-row">'
                        '%(help_text)s'
                        '</div>',
             error_row='<div class="form-row">'
                       '<div class="form-label"></div>'
                       '<div class="form-errors">%s</div>'
                       '</div>',
             row_ender='</div>',
             help_text_html='%s',
             errors_on_separate_row=True)
 
     def as_json_errors(self):
         errors = []
 
         for name, field in self.fields.items():
             if self[name].errors:
                 errors.append({
                     'field': name,
                     'errors': self[name].errors.as_text(),
                 })
 
         return errors
 
 
 class PostForm(NeboardForm):
 
     title = forms.CharField(max_length=TITLE_MAX_LENGTH, required=False,
                             label=LABEL_TITLE)
     text = forms.CharField(
         widget=FormatPanel(attrs={ATTRIBUTE_PLACEHOLDER: TEXT_PLACEHOLDER}),
         required=False, label=LABEL_TEXT)
     image = forms.ImageField(required=False, label=_('Image'),
-            widget=forms.ClearableFileInput(attrs={'accept': 'image/*'}))
+                             widget=forms.ClearableFileInput(
+                                 attrs={'accept': 'image/*'}))
 
     # This field is for spam prevention only
     email = forms.CharField(max_length=100, required=False, label=_('e-mail'),
                             widget=forms.TextInput(attrs={
                                 'class': 'form-email'}))
 
     session = None
     need_to_ban = False
 
     def clean_title(self):
         title = self.cleaned_data['title']
         if title:
             if len(title) > TITLE_MAX_LENGTH:
                 raise forms.ValidationError(_('Title must have less than %s '
                                               'characters') %
                                             str(TITLE_MAX_LENGTH))
         return title
 
     def clean_text(self):
         text = self.cleaned_data['text'].strip()
         if text:
             if len(text) > board_settings.MAX_TEXT_LENGTH:
                 raise forms.ValidationError(_('Text must have less than %s '
                                               'characters') %
                                             str(board_settings
                                             .MAX_TEXT_LENGTH))
         return text
 
     def clean_image(self):
         image = self.cleaned_data['image']
         if image:
-            if image._size > board_settings.MAX_IMAGE_SIZE:
+            if image.size > board_settings.MAX_IMAGE_SIZE:
                 raise forms.ValidationError(
                     _('Image must be less than %s bytes')
                     % str(board_settings.MAX_IMAGE_SIZE))
 
             md5 = hashlib.md5()
             for chunk in image.chunks():
                 md5.update(chunk)
             image_hash = md5.hexdigest()
             if PostImage.objects.filter(hash=image_hash).exists():
                 raise forms.ValidationError(ERROR_IMAGE_DUPLICATE)
 
         return image
 
     def clean(self):
         cleaned_data = super(PostForm, self).clean()
 
         if not self.session:
             raise forms.ValidationError('Humans have sessions')
 
         if cleaned_data['email']:
             self.need_to_ban = True
             raise forms.ValidationError('A human cannot enter a hidden field')
 
         if not self.errors:
             self._clean_text_image()
 
         if not self.errors and self.session:
             self._validate_posting_speed()
 
         return cleaned_data
 
     def _clean_text_image(self):
         text = self.cleaned_data.get('text')
         image = self.cleaned_data.get('image')
 
         if (not text) and (not image):
             error_message = _('Either text or image must be entered.')
             self._errors['text'] = self.error_class([error_message])
 
     def _validate_posting_speed(self):
         can_post = True
 
         # TODO Remove this, it's only for test
         if not 'user_id' in self.session:
             return
 
         user = User.objects.get(id=self.session['user_id'])
         if user.is_veteran():
             posting_delay = VETERAN_POSTING_DELAY
         else:
             posting_delay = settings.POSTING_DELAY
 
         if LAST_POST_TIME in self.session:
             now = time.time()
             last_post_time = self.session[LAST_POST_TIME]
 
             current_delay = int(now - last_post_time)
 
             if current_delay < posting_delay:
                 error_message = _('Wait %s seconds after last posting') % str(
                     posting_delay - current_delay)
                 self._errors['text'] = self.error_class([error_message])
 
                 can_post = False
 
         if can_post:
             self.session[LAST_POST_TIME] = time.time()
 
 
 class ThreadForm(PostForm):
 
     regex_tags = re.compile(ur'^[\w\s\d]+$', re.UNICODE)
 
     tags = forms.CharField(
         widget=forms.TextInput(attrs={ATTRIBUTE_PLACEHOLDER: TAGS_PLACEHOLDER}),
         max_length=100, label=_('Tags'), required=True)
 
     def clean_tags(self):
         tags = self.cleaned_data['tags'].strip()
 
         if not tags or not self.regex_tags.match(tags):
             raise forms.ValidationError(
                 _('Inappropriate characters in tags.'))
 
         return tags
 
     def clean(self):
         cleaned_data = super(ThreadForm, self).clean()
 
         return cleaned_data
 
 
 class PostCaptchaForm(PostForm):
     captcha = CaptchaField()
 
     def __init__(self, *args, **kwargs):
         self.request = kwargs['request']
         del kwargs['request']
 
         super(PostCaptchaForm, self).__init__(*args, **kwargs)
 
     def clean(self):
         cleaned_data = super(PostCaptchaForm, self).clean()
 
         success = self.is_valid()
         utils.update_captcha_access(self.request, success)
 
         if success:
             return cleaned_data
         else:
             raise forms.ValidationError(_("Captcha validation failed"))
 
 
 class ThreadCaptchaForm(ThreadForm):
     captcha = CaptchaField()
 
     def __init__(self, *args, **kwargs):
         self.request = kwargs['request']
         del kwargs['request']
 
         super(ThreadCaptchaForm, self).__init__(*args, **kwargs)
 
     def clean(self):
         cleaned_data = super(ThreadCaptchaForm, self).clean()
 
         success = self.is_valid()
         utils.update_captcha_access(self.request, success)
 
         if success:
             return cleaned_data
         else:
             raise forms.ValidationError(_("Captcha validation failed"))
 
 
 class SettingsForm(NeboardForm):
 
     theme = forms.ChoiceField(choices=settings.THEMES,
                               label=_('Theme'))
 
 
 class ModeratorSettingsForm(SettingsForm):
 
     moderate = forms.BooleanField(required=False, label=_('Enable moderation '
                                                           'panel'))
 
 
 class LoginForm(NeboardForm):
 
     user_id = forms.CharField()
 
     session = None
 
     def clean_user_id(self):
         user_id = self.cleaned_data['user_id']
         if user_id:
             users = User.objects.filter(user_id=user_id)
             if len(users) == 0:
                 raise forms.ValidationError(_('No such user found'))
 
         return user_id
 
     def _validate_login_speed(self):
         can_post = True
 
         if LAST_LOGIN_TIME in self.session:
             now = time.time()
             last_login_time = self.session[LAST_LOGIN_TIME]
 
             current_delay = int(now - last_login_time)
 
             if current_delay < board_settings.LOGIN_TIMEOUT:
                 error_message = _('Wait %s minutes after last login') % str(
                     (board_settings.LOGIN_TIMEOUT - current_delay) / 60)
                 self._errors['user_id'] = self.error_class([error_message])
 
                 can_post = False
 
         if can_post:
             self.session[LAST_LOGIN_TIME] = time.time()
 
     def clean(self):
         if not self.session:
             raise forms.ValidationError('Humans have sessions')
 
         self._validate_login_speed()
 
         cleaned_data = super(LoginForm, self).clean()
 
         return cleaned_data
 
 
 class AddTagForm(NeboardForm):
 
     tag = forms.CharField(max_length=TAG_MAX_LENGTH, label=LABEL_TAG)
     method = forms.CharField(widget=forms.HiddenInput(), initial='add_tag')
 
     def clean_tag(self):
         tag = self.cleaned_data['tag']
 
         regex_tag = re.compile(REGEX_TAG, re.UNICODE)
         if not regex_tag.match(tag):
             raise forms.ValidationError(_('Inappropriate characters in tags.'))
 
         return tag
 
     def clean(self):
         cleaned_data = super(AddTagForm, self).clean()
 
         return cleaned_data
 
 
 class SearchForm(NeboardForm):
     query = forms.CharField(max_length=500, label=LABEL_SEARCH, required=False)
  No newline at end of file

boards/mdx_neboard.py

@@ -1,202 +1,207
 # coding=utf-8
 
 import markdown
-from markdown.inlinepatterns import Pattern, SubstituteTagPattern
+from markdown.inlinepatterns import Pattern
 from markdown.util import etree
+
 import boards
 
+
 __author__ = 'neko259'
 
 
 AUTOLINK_PATTERN = r'(https?://\S+)'
 QUOTE_PATTERN = r'^(?<!>)(>[^>].*)$'
 REFLINK_PATTERN = r'((>>)(\d+))'
 SPOILER_PATTERN = r'%%([^(%%)]+)%%'
 COMMENT_PATTERN = r'^(//(.+))'
 STRIKETHROUGH_PATTERN = r'~(.+)~'
 DASH_PATTERN = r'--'
 
 
 class TextFormatter():
     """
     An interface for formatter that can be used in the text format panel
     """
 
+    def __init__(self):
+        pass
+
     name = ''
 
     # Left and right tags for the button preview
     preview_left = ''
     preview_right = ''
 
     # Left and right characters for the textarea input
     format_left = ''
     format_right = ''
 
 
 class AutolinkPattern(Pattern):
     def handleMatch(self, m):
         link_element = etree.Element('a')
         href = m.group(2)
         link_element.set('href', href)
         link_element.text = href
 
         return link_element
 
 
 class QuotePattern(Pattern, TextFormatter):
     name = ''
     preview_left = '<span class="quote">&gt; '
     preview_right = '</span>'
 
     format_left = '&gt;'
 
     def handleMatch(self, m):
         quote_element = etree.Element('span')
         quote_element.set('class', 'quote')
         quote_element.text = m.group(2)
 
         return quote_element
 
 
 class ReflinkPattern(Pattern):
     def handleMatch(self, m):
         post_id = m.group(4)
 
         posts = boards.models.Post.objects.filter(id=post_id)
         if posts.count() > 0:
             ref_element = etree.Element('a')
 
             post = posts[0]
 
             ref_element.set('href', post.get_url())
             ref_element.text = m.group(2)
 
             return ref_element
 
 
 class SpoilerPattern(Pattern, TextFormatter):
     name = 's'
     preview_left = '<span class="spoiler">'
     preview_right = '</span>'
 
     format_left = '%%'
     format_right = '%%'
 
     def handleMatch(self, m):
         quote_element = etree.Element('span')
         quote_element.set('class', 'spoiler')
         quote_element.text = m.group(2)
 
         return quote_element
 
 
 class CommentPattern(Pattern, TextFormatter):
     name = ''
     preview_left = '<span class="comment">// '
     preview_right = '</span>'
 
     format_left = '//'
 
     def handleMatch(self, m):
         quote_element = etree.Element('span')
         quote_element.set('class', 'comment')
         quote_element.text = '//' + m.group(3)
 
         return quote_element
 
 
 class StrikeThroughPattern(Pattern, TextFormatter):
     name = 's'
     preview_left = '<span class="strikethrough">'
     preview_right = '</span>'
 
     format_left = '~'
     format_right = '~'
 
     def handleMatch(self, m):
         quote_element = etree.Element('span')
         quote_element.set('class', 'strikethrough')
         quote_element.text = m.group(2)
 
         return quote_element
 
 
 class ItalicPattern(TextFormatter):
     name = 'i'
     preview_left = '<i>'
     preview_right = '</i>'
 
     format_left = '_'
     format_right = '_'
 
 
 class BoldPattern(TextFormatter):
     name = 'b'
     preview_left = '<b>'
     preview_right = '</b>'
 
     format_left = '__'
     format_right = '__'
 
 
 class CodePattern(TextFormatter):
     name = 'code'
     preview_left = '<code>'
     preview_right = '</code>'
 
     format_left = '    '
 
 
 class DashPattern(Pattern):
     def handleMatch(self, m):
         return u'—'
 
 
 class NeboardMarkdown(markdown.Extension):
     def extendMarkdown(self, md, md_globals):
         self._add_neboard_patterns(md)
         self._delete_patterns(md)
 
     def _delete_patterns(self, md):
         del md.parser.blockprocessors['quote']
 
         del md.inlinePatterns['image_link']
         del md.inlinePatterns['image_reference']
 
     def _add_neboard_patterns(self, md):
         autolink = AutolinkPattern(AUTOLINK_PATTERN, md)
         quote = QuotePattern(QUOTE_PATTERN, md)
         reflink = ReflinkPattern(REFLINK_PATTERN, md)
         spoiler = SpoilerPattern(SPOILER_PATTERN, md)
         comment = CommentPattern(COMMENT_PATTERN, md)
         strikethrough = StrikeThroughPattern(STRIKETHROUGH_PATTERN, md)
         dash = DashPattern(DASH_PATTERN, md)
 
         md.inlinePatterns[u'autolink_ext'] = autolink
         md.inlinePatterns[u'spoiler'] = spoiler
         md.inlinePatterns[u'strikethrough'] = strikethrough
         md.inlinePatterns[u'comment'] = comment
         md.inlinePatterns[u'reflink'] = reflink
         md.inlinePatterns[u'quote'] = quote
         md.inlinePatterns[u'dash'] = dash
 
 
 def make_extension(configs=None):
     return NeboardMarkdown(configs=configs)
 
 neboard_extension = make_extension()
 
 
 def markdown_extended(markup):
     return markdown.markdown(markup, [neboard_extension, 'nl2br'],
                              safe_mode='escape')
 
 formatters = [
     QuotePattern,
     SpoilerPattern,
     ItalicPattern,
     BoldPattern,
     CommentPattern,
     StrikeThroughPattern,
     CodePattern,
 ]

boards/middlewares.py

@@ -1,42 +1,46
 from django.shortcuts import redirect
 from boards import utils
 from boards.models import Ban
 from django.utils.html import strip_spaces_between_tags
 from django.conf import settings
 from boards.views.banned import BannedView
 
 RESPONSE_CONTENT_TYPE = 'Content-Type'
 
 TYPE_HTML = 'text/html'
 
 
 class BanMiddleware:
     """
     This is run before showing the thread. Banned users don't need to see
     anything
     """
 
+    def __init__(self):
+        pass
+
     def process_view(self, request, view_func, view_args, view_kwargs):
 
         if view_func != BannedView.as_view:
             ip = utils.get_client_ip(request)
             bans = Ban.objects.filter(ip=ip)
 
             if bans.exists():
                 ban = bans[0]
                 if not ban.can_read:
                     return redirect('banned')
 
 
 class MinifyHTMLMiddleware(object):
     def process_response(self, request, response):
         try:
             compress_html = settings.COMPRESS_HTML
         except AttributeError:
             compress_html = False
 
         if RESPONSE_CONTENT_TYPE in response\
-            and TYPE_HTML in response[RESPONSE_CONTENT_TYPE] and compress_html:
+                and TYPE_HTML in response[RESPONSE_CONTENT_TYPE]\
+                and compress_html:
             response.content = strip_spaces_between_tags(
                 response.content.strip())
         return response
  No newline at end of file

boards/profiler.py

@@ -1,23 +1,26
 import sys
 from cStringIO import StringIO
 from django.conf import settings
 import line_profiler
 
 
-class ProfilerMiddleware(object):
+class ProfilerMiddleware():
+    def __init__(self):
+        self.profiler = None
+
     def process_view(self, request, callback, callback_args, callback_kwargs):
         if settings.DEBUG and 'prof' in request.GET:
             self.profiler = line_profiler.LineProfiler()
             self.profiler.add_function(callback)
             self.profiler.enable()
             args = (request,) + callback_args
             return callback(*args, **callback_kwargs)
 
     def process_response(self, request, response):
         if settings.DEBUG and 'prof' in request.GET:
             out = StringIO()
             old_stdout, sys.stdout = sys.stdout, out
             self.profiler.print_stats()
             sys.stdout = old_stdout
             response.content = '<pre>%s</pre>' % out.getvalue()
         return response

boards/views/search.py

@@ -1,33 +1,41
 from django.shortcuts import render
 from django.template import RequestContext
 from django.views.generic import View
 from haystack.query import SearchQuerySet
 from boards.abstracts.paginator import get_paginator
 from boards.forms import SearchForm, PlainErrorList
 
+FORM_QUERY = 'query'
+
+CONTEXT_QUERY = 'query'
+CONTEXT_FORM = 'form'
+CONTEXT_PAGE = 'page'
+
+REQUEST_PAGE = 'page'
+
 __author__ = 'neko259'
 
 TEMPLATE = 'search/search.html'
 
 
 class BoardSearchView(View):
     def get(self, request):
         context = RequestContext(request)
         form = SearchForm(request.GET, error_class=PlainErrorList)
-        context['form'] = form
+        context[CONTEXT_FORM] = form
 
         if form.is_valid():
-            query = form.cleaned_data['query']
+            query = form.cleaned_data[FORM_QUERY]
             if len(query) >= 3:
                 results = SearchQuerySet().auto_query(query).order_by('-id') \
                     .highlight()
                 paginator = get_paginator(results, 10)
 
-                if 'page' in request.GET:
-                    page = int(request.GET['page'])
+                if REQUEST_PAGE in request.GET:
+                    page = int(request.GET[REQUEST_PAGE])
                 else:
                     page = 1
-                context['page'] = paginator.page(page)
-                context['query'] = query
+                context[CONTEXT_PAGE] = paginator.page(page)
+                context[CONTEXT_QUERY] = query
 
         return render(request, TEMPLATE, context)
  No newline at end of file

requirements.txt

@@ -1,9 +1,10
+line_profiler
 haystack
 pillow
 django>=1.6
 django_cleanup
 django-markupfield
 markdown
 python-markdown
 django-simple-captcha
 line-profiler