Implemented RSS support. This fixes #11

boards/rss.py

@@ -0,0 +1,74 b''
+from django.contrib.syndication.views import Feed
+from django.core.urlresolvers import reverse
+from django.shortcuts import get_object_or_404
+from boards.models import Post, Tag, NO_PARENT
+from neboard import settings
+
+__author__ = 'neko259'
+
+
+class AllThreadsFeed(Feed):
+    title = settings.SITE_NAME + ' - All threads'
+    link = '/'
+    description_template = 'boards/rss/post.html'
+
+    def items(self):
+        return Post.objects.get_threads(order_by='-pub_time')
+
+    def item_title(self, item):
+        return item.title
+
+    def item_link(self, item):
+        return reverse('thread', args={item.id})
+
+    def item_pubdate(self, item):
+        return item.pub_time
+
+
+class TagThreadsFeed(Feed):
+    link = '/'
+    description_template = 'boards/rss/post.html'
+
+    def items(self, obj):
+        return Post.objects.get_threads(tag=obj, order_by='-pub_time')
+
+    def get_object(self, request, tag_name):
+        return get_object_or_404(Tag, name=tag_name)
+
+    def item_title(self, item):
+        return item.title
+
+    def item_link(self, item):
+        return reverse('thread', args={item.id})
+
+    def item_pubdate(self, item):
+        return item.pub_time
+
+    def title(self, obj):
+        return obj.name
+
+
+class ThreadPostsFeed(Feed):
+    link = '/'
+    description_template = 'boards/rss/post.html'
+
+    def items(self, obj):
+        return Post.objects.get_thread(opening_post_id=obj)
+
+    def get_object(self, request, post_id):
+        return post_id
+
+    def item_title(self, item):
+        return item.title
+
+    def item_link(self, item):
+        if NO_PARENT == item.parent:
+            return reverse('thread', args={item.id})
+        else:
+            return reverse('thread', args={item.parent}) + "#" + str(item.id)
+
+    def item_pubdate(self, item):
+        return item.pub_time
+
+    def title(self, obj):
+        return get_object_or_404(Post, id=obj).title
  No newline at end of file

boards/templates/boards/rss/post.html

@@ -0,0 +1,15 b''
+{% load i18n %}
+
+{% if obj.image %}
+<img src="{{ obj.image.url_200x150 }}"
+        alt="{% trans 'Post image' %}" />
+{% endif %}
+{{ obj.text.rendered|safe }}
+{%  if obj.tags.all %}
+    <p>
+        {% trans 'Tags' %}:
+        {% for tag in obj.tags.all %}
+            {{ tag.name }}
+        {% endfor %}
+    </p>
+{% endif %}
  No newline at end of file

boards/mdx_neboard.py

@@ -1,83 +1,83 b''
 import markdown
 from markdown.inlinepatterns import Pattern
 from markdown.util import etree
 
-__author__ = 'vurdalak'
+__author__ = 'neko259'
 
 
 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):
     def handleMatch(self, m):
         quote_element = etree.Element('span')
         quote_element.set('class', 'quote')
         quote_element.text = m.group(3)
 
         return quote_element
 
 
 class ReflinkPattern(Pattern):
     def handleMatch(self, m):
         ref_element = etree.Element('a')
         post_id = m.group(4)
         ref_element.set('href', '#' + str(post_id))
         ref_element.text = '#' + post_id
 
         return ref_element
 
 
 class SpoilerPattern(Pattern):
     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):
     def handleMatch(self, m):
         quote_element = etree.Element('span')
         quote_element.set('class', 'comment')
         quote_element.text = '//' + m.group(3)
 
         return quote_element
 
 
 class NeboardMarkdown(markdown.Extension):
     AUTOLINK_PATTERN = r'(https?://\S+)'
     QUOTE_PATTERN = r'^(>){1}(.+)'
     REFLINK_PATTERN = r'((>){2}(\d+))'
     SPOILER_PATTERN = r'%%(.+)%%'
     COMMENT_PATTERN = r'^(//(.+))'
 
     def extendMarkdown(self, md, md_globals):
         autolink = AutolinkPattern(self.AUTOLINK_PATTERN, md)
         quote = QuotePattern(self.QUOTE_PATTERN, md)
         reflink = ReflinkPattern(self.REFLINK_PATTERN, md)
         spoiler = SpoilerPattern(self.SPOILER_PATTERN, md)
         comment = CommentPattern(self.COMMENT_PATTERN, md)
 
         md.inlinePatterns[u'autolink_ext'] = autolink
         md.inlinePatterns.add(u'reflink', reflink, '<entity')
         md.inlinePatterns.add(u'quote', quote, '<entity')
         md.inlinePatterns[u'spoiler'] = spoiler
         md.inlinePatterns[u'comment'] = comment
 
 
 def makeExtension(configs=None):
     return NeboardMarkdown(configs=configs)
 
 neboard_extension = makeExtension()
 
 
 def markdown_extended(markup):
     return markdown.markdown(markup, [neboard_extension])

boards/templates/boards/base.html

@@ -1,45 +1,46 b''
 {% load staticfiles %}
 {% load i18n %}
 
 <!DOCTYPE html>
 <html>
 <head>
     <link rel="stylesheet" type="text/css"
           href="{{ STATIC_URL }}css/jquery.fancybox.css" media="all"/>
     <link rel="stylesheet" type="text/css"
           href="{{ STATIC_URL }}css/{{ theme }}/base_page.css" media="all"/>
     <meta name="viewport" content="width=device-width, initial-scale=1"/>
     <meta charset="utf-8"/>
     {% block head %}{% endblock %}
 </head>
 <body>
 <script src="{{ STATIC_URL }}js/jquery-2.0.1.min.js"></script>
 <script src="{{ STATIC_URL }}js/jquery.fancybox.pack.js"></script>
 <script src="{{ STATIC_URL }}js/main.js"></script>
 <div id="admin_panel">
 
     {% if request.session.admin == True %}
         Admin panel TODO: Need to implement <BR />
     {% endif %}
 
 </div>
 
 <div class="navigation_panel">
     <a class="link" href="{% url 'index' %}">{% trans "All threads" %}</a>
     {% for tag in tags %}
         <a class="tag" href=" {% url 'tag' tag_name=tag.name %}">
             {{ tag.name }}</a>({{ tag.get_post_count }})
     {% endfor %}
     <a class="tag" href="{% url 'tags' %}">[...]</a>
     <a class="link" href="{% url 'settings' %}">{% trans 'Settings' %}</a>
 </div>
 
 {% block content %}{% endblock %}
 
 <div class="navigation_panel">
     {% block metapanel %}{% endblock %}
+    [<a href="rss/">RSS</a>]
     <a class="link" href="#top">{% trans 'Up' %}</a>
 </div>
 
 </body>
 </html>
  No newline at end of file

boards/tests.py

@@ -1,218 +1,218 b''
 # coding=utf-8
 from django.utils.unittest import TestCase
 from django.test.client import Client
 
 import boards
 
 from boards.models import Post, Admin, Tag
 from neboard import settings
 
 TEST_TEXT = 'test text'
 
 NEW_THREAD_PAGE = '/'
 THREAD_PAGE_ONE = '/thread/1/'
 THREAD_PAGE = '/thread/'
 TAG_PAGE = '/tag/'
 HTTP_CODE_REDIRECT = 302
 HTTP_CODE_OK = 200
 HTTP_CODE_NOT_FOUND = 404
 
 
 class BoardTests(TestCase):
     def _create_post(self):
         return Post.objects.create_post(title='title',
                                         text='text')
 
     def test_post_add(self):
         post = self._create_post()
 
         self.assertIsNotNone(post)
         self.assertEqual(boards.models.NO_PARENT, post.parent)
 
     def test_delete_post(self):
         post = self._create_post()
         post_id = post.id
 
         Post.objects.delete_post(post)
 
         self.assertFalse(Post.objects.exists(post_id))
 
     def test_delete_posts_by_ip(self):
         post = self._create_post()
         post_id = post.id
 
         Post.objects.delete_posts_by_ip('0.0.0.0')
 
         self.assertFalse(Post.objects.exists(post_id))
 
     # Authentication tests
 
     def _create_test_user(self):
         admin = Admin(name='test_username12313584353165',
                       password='test_userpassword135135512')
 
         admin.save()
         return admin
 
     def test_admin_login(self):
         client = Client()
 
         self.assertFalse('admin' in client.session)
 
         admin = self._create_test_user()
 
         response = client.post('/login',
                                {'name': admin.name, 'password': admin.password})
 
         # it means that login passed and user are redirected to another page
         self.assertEqual(302, response.status_code)
 
         self.assertTrue('admin' in client.session)
         self.assertTrue(client.session['admin'])
 
         admin.delete()
 
         wrong_name = 'sd2f1s3d21fs3d21f'
         wrong_password = 'sd2f1s3d21fs3d21fsdfsd'
 
         client.post('/login', {'name': wrong_name, 'password': wrong_password})
         self.assertFalse(client.session['admin'])
 
     def test_admin_logout(self):
         client = Client()
 
         self.assertFalse('admin' in client.session)
 
         admin = self._create_test_user()
 
         client.post('/login',
                     {'name': admin.name, 'password': admin.password})
 
         self.assertTrue(client.session['admin'])
 
         client.get('/logout')
 
         self.assertFalse(client.session['admin'])
 
         admin.delete()
 
     def test_get_thread(self):
         opening_post = self._create_post()
         op_id = opening_post.id
 
         for i in range(0, 2):
             Post.objects.create_post('title', 'text',
                                      parent_id=op_id)
 
         thread = Post.objects.get_thread(op_id)
 
         self.assertEqual(3, len(thread))
 
     def test_create_post_with_tag(self):
         tag = Tag.objects.create(name='test_tag')
         post = Post.objects.create_post(title='title', text='text', tags=[tag])
         self.assertIsNotNone(post)
 
     def test_thread_max_count(self):
         for i in range(settings.MAX_THREAD_COUNT + 1):
             self._create_post()
 
         self.assertEqual(settings.MAX_THREAD_COUNT,
                          len(Post.objects.get_threads()))
 
     def test_get(self):
         """Test if the get computes properly"""
 
         post = self._create_post()
 
         self.assertTrue(post.is_get())
 
     def test_pages(self):
         """Test that the thread list is properly split into pages"""
 
         for i in range(settings.MAX_THREAD_COUNT):
             self._create_post()
 
         all_threads = Post.objects.get_threads()
 
         posts_in_second_page = Post.objects.get_threads(page=1)
         first_post = posts_in_second_page[0]
 
         self.assertEqual(all_threads[settings.THREADS_PER_PAGE].id,
                          first_post.id)
 
     def test_post_validation(self):
         """Test the validation of the post form"""
 
         Post.objects.all().delete()
 
         client = Client()
 
         valid_tags = u'tag1 tag_2 тег_3'
         invalid_tags = u'$%_356 ---'
 
         response = client.post(NEW_THREAD_PAGE, {'title': 'test title',
                                                  'text': TEST_TEXT,
                                                  'tags': valid_tags})
         self.assertEqual(response.status_code, HTTP_CODE_REDIRECT,
                          msg='Posting new message failed: got code ' +
                              str(response.status_code))
 
         self.assertEqual(1, Post.objects.count(),
                          msg='No posts were created')
 
         client.post(NEW_THREAD_PAGE, {'text': TEST_TEXT,
                                       'tags': invalid_tags})
         self.assertEqual(1, Post.objects.count(), msg='The validation passed '
                                                       'where it should fail')
 
         response = client.post(THREAD_PAGE_ONE, {'text': TEST_TEXT,
-                                             'tags': valid_tags})
+                                                 'tags': valid_tags})
         self.assertEqual(HTTP_CODE_REDIRECT, response.status_code,
                          msg=u'Posting new message failed: got code ' +
                              str(response.status_code))
 
         self.assertEqual(2, Post.objects.count(),
                          msg=u'No posts were created')
 
     def test_404(self):
         """Test receiving error 404 when opening a non-existent page"""
 
         Post.objects.all().delete()
         Tag.objects.all().delete()
 
         tag_name = u'test_tag'
         tags, = [Tag.objects.get_or_create(name=tag_name)]
         client = Client()
 
         Post.objects.create_post('title', TEST_TEXT, tags=tags)
 
         existing_post_id = Post.objects.all()[0].id
         response_existing = client.get(THREAD_PAGE + str(existing_post_id) +
                                        '/')
         self.assertEqual(HTTP_CODE_OK, response_existing.status_code,
                          u'Cannot open existing thread')
 
         response_not_existing = client.get(THREAD_PAGE + str(
             existing_post_id + 1) + '/')
         self.assertEqual(HTTP_CODE_NOT_FOUND,
                          response_not_existing.status_code,
                          u'Not existing thread is opened')
 
         response_existing = client.get(TAG_PAGE + tag_name + '/')
         self.assertEqual(HTTP_CODE_OK,
                          response_existing.status_code,
                          u'Cannot open existing tag')
 
         response_not_existing = client.get(TAG_PAGE + u'not_tag' + '/')
         self.assertEqual(HTTP_CODE_NOT_FOUND,
                          response_not_existing.status_code,
                          u'Not existing tag is opened')
 
         reply_id = Post.objects.create_post('', TEST_TEXT,
                                             parent_id=existing_post_id)
         response_not_existing = client.get(THREAD_PAGE + str(
             reply_id) + '/')
         self.assertEqual(HTTP_CODE_NOT_FOUND,
                          response_not_existing.status_code,
                          u'Not existing thread is opened')

boards/urls.py

@@ -1,26 +1,32 b''
 from django.conf.urls import patterns, url, include
 from boards import views
+from boards.rss import AllThreadsFeed, TagThreadsFeed, ThreadPostsFeed
 
 urlpatterns = patterns('',
 
     # /boards/
     url(r'^$', views.index, name='index'),
     # /boards/page/
     url(r'^page/(?P<page>\w+)/$', views.index, name='index'),
 
     # login page
     url(r'^login$', views.login, name='login'),
     # logout page
     url(r'^logout$', views.logout, name='logout'),
 
     # /boards/tag/tag_name/
     url(r'^tag/(?P<tag_name>\w+)/$', views.tag, name='tag'),
     # /boards/tag/tag_id/page/
     url(r'^tag/(?P<tag_name>\w+)/page/(?P<page>\w+)/$', views.tag, name='tag'),
     # /boards/thread/
     url(r'^thread/(?P<post_id>\w+)/$', views.thread, name='thread'),
     # /boards/theme/theme_name/
     url(r'^settings$', views.settings, name='settings'),
     url(r'^tags$', views.all_tags, name='tags'),
     url(r'^captcha/', include('captcha.urls')),
+
+    # RSS feeds
+    url(r'^rss/$', AllThreadsFeed()),
+    url(r'^tag/(?P<tag_name>\w+)/rss/$', TagThreadsFeed()),
+    url(r'^thread/(?P<post_id>\w+)/rss/$', ThreadPostsFeed()),
 )
  No newline at end of file

neboard/settings.py

@@ -1,195 +1,195 b''
 # Django settings for neboard project.
 import os
 import markdown
 from boards.mdx_neboard import markdown_extended
 
 DEBUG = True
 TEMPLATE_DEBUG = DEBUG
 
 ADMINS = (
     # ('Your Name', '[e-mail]'),
     ('admin', '[e-mail]')
 )
 
 MANAGERS = ADMINS
 
 DATABASES = {
     'default': {
         'ENGINE': 'django.db.backends.sqlite3', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
         'NAME': 'database.db',                      # Or path to database file if using sqlite3.
         'USER': '',                      # Not used with sqlite3.
         'PASSWORD': '',                  # Not used with sqlite3.
         'HOST': '',                      # Set to empty string for localhost. Not used with sqlite3.
         'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
     }
 }
 
 # Local time zone for this installation. Choices can be found here:
 # http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
 # although not all choices may be available on all operating systems.
 # In a Windows environment this must be set to your system time zone.
 TIME_ZONE = 'Europe/Kiev'
 
 # Language code for this installation. All choices can be found here:
 # http://www.i18nguy.com/unicode/language-identifiers.html
 LANGUAGE_CODE = 'ru-RU'
 
 SITE_ID = 1
 
 # If you set this to False, Django will make some optimizations so as not
 # to load the internationalization machinery.
 USE_I18N = True
 
 # If you set this to False, Django will not format dates, numbers and
 # calendars according to the current locale.
 USE_L10N = True
 
 # If you set this to False, Django will not use timezone-aware datetimes.
 USE_TZ = True
 
 # Absolute filesystem path to the directory that will hold user-uploaded files.
 # Example: "/home/media/media.lawrence.com/media/"
 MEDIA_ROOT = './media/' 
 
 # URL that handles the media served from MEDIA_ROOT. Make sure to use a
 # trailing slash.
 # Examples: "http://media.lawrence.com/media/", "http://example.com/media/"
 MEDIA_URL = '/media/'
 
 # Absolute path to the directory static files should be collected to.
 # Don't put anything in this directory yourself; store your static files
 # in apps' "static/" subdirectories and in STATICFILES_DIRS.
 # Example: "/home/media/media.lawrence.com/static/"
 STATIC_ROOT = ''
 
 # URL prefix for static files.
 # Example: "http://media.lawrence.com/static/"
 STATIC_URL = '/static/'
 
 # Additional locations of static files
 # It is really a hack, put real paths, not related
 STATICFILES_DIRS = (
     os.path.dirname(__file__) + '/boards/static',
 
 #    '/d/work/python/django/neboard/neboard/boards/static',
     # Put strings here, like "/home/html/static" or "C:/www/django/static".
     # Always use forward slashes, even on Windows.
     # Don't forget to use absolute paths, not relative paths.
 )
 
 # List of finder classes that know how to find static files in
 # various locations.
 STATICFILES_FINDERS = (
     'django.contrib.staticfiles.finders.FileSystemFinder',
     'django.contrib.staticfiles.finders.AppDirectoriesFinder',
 #    'django.contrib.staticfiles.finders.DefaultStorageFinder',
 )
 
 # Make this unique, and don't share it with anybody.
 SECRET_KEY = '@1rc$o(7=tt#kd+4s$u6wchm**z^)4x90)7f6z(i&55@o11*8o'
 
 # List of callables that know how to import templates from various sources.
 TEMPLATE_LOADERS = (
     'django.template.loaders.filesystem.Loader',
     'django.template.loaders.app_directories.Loader',
 #     'django.template.loaders.eggs.Loader',
 )
 
 TEMPLATE_CONTEXT_PROCESSORS = (
     'django.core.context_processors.media',
     'django.core.context_processors.static',
     'django.core.context_processors.request',
     'django.contrib.auth.context_processors.auth',
 )
 
 MIDDLEWARE_CLASSES = (
     'django.middleware.common.CommonMiddleware',
     'django.contrib.sessions.middleware.SessionMiddleware',
 #    'django.middleware.csrf.CsrfViewMiddleware',
     'django.contrib.auth.middleware.AuthenticationMiddleware',
     'django.contrib.messages.middleware.MessageMiddleware',
     # Uncomment the next line for simple clickjacking protection:
     # 'django.middleware.clickjacking.XFrameOptionsMiddleware',
 )
 
 ROOT_URLCONF = 'neboard.urls'
 
 # Python dotted path to the WSGI application used by Django's runserver.
 WSGI_APPLICATION = 'neboard.wsgi.application'
 
 TEMPLATE_DIRS = (
     # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
     # Always use forward slashes, even on Windows.
     # Don't forget to use absolute paths, not relative paths.
     'templates',
 )
 
 INSTALLED_APPS = (
     'django.contrib.auth',
     'django.contrib.contenttypes',
     'django.contrib.sessions',
-    'django.contrib.sites',
+    # 'django.contrib.sites',
     'django.contrib.messages',
     'django.contrib.staticfiles',
     # Uncomment the next line to enable the admin:
      'django.contrib.admin',
     # Uncomment the next line to enable admin documentation:
     # 'django.contrib.admindocs',
     'django.contrib.markup',
     'django_cleanup',
     'boards',
     'captcha',
 )
 
 # TODO: NEED DESIGN FIXES
 CAPTCHA_OUTPUT_FORMAT = (u' %(hidden_field)s '
                          u'<div class="form-label">%(image)s</div>'
                          u'<div class="form-text">%(text_field)s</div>')
 
 # A sample logging configuration. The only tangible logging
 # performed by this configuration is to send an email to
 # the site admins on every HTTP 500 error when DEBUG=False.
 # See http://docs.djangoproject.com/en/dev/topics/logging for
 # more details on how to customize your logging configuration.
 LOGGING = {
     'version': 1,
     'disable_existing_loggers': False,
     'filters': {
         'require_debug_false': {
             '()': 'django.utils.log.RequireDebugFalse'
         }
     },
     'handlers': {
         'mail_admins': {
             'level': 'ERROR',
             'filters': ['require_debug_false'],
             'class': 'django.utils.log.AdminEmailHandler'
         }
     },
     'loggers': {
         'django.request': {
             'handlers': ['mail_admins'],
             'level': 'ERROR',
             'propagate': True,
         },
     }
 }
 
 MARKUP_FIELD_TYPES = (
     ('markdown', markdown_extended),
 )
 # Custom imageboard settings
 MAX_POSTS_PER_THREAD = 10 # Thread bumplimit
 MAX_THREAD_COUNT = 500 # Old threads will be deleted to preserve this count
 THREADS_PER_PAGE = 10
 SITE_NAME = 'Neboard'
 
 THEMES = [
     ('md', 'Mystic Dark'),
     ('sw', 'Snow White') ]
 DEFAULT_THEME = 'md'
 
 POPULAR_TAGS = 10
 LAST_REPLIES_COUNT = 3
 
 ENABLE_CAPTCHA = False
  No newline at end of file