mirror of
https://github.com/getpelican/pelican.git
synced 2025-10-15 20:28:56 +02:00
remove plugins, update docs and update dependecies
This commit is contained in:
Deniz Turgut
parent
886c8d649c
commit
c4b3ad58e8
20 changed files with 16 additions and 1193 deletions
|
|
@ -1,53 +0,0 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
from __future__ import unicode_literals
|
||||
"""
|
||||
Asset management plugin for Pelican
|
||||
===================================
|
||||
|
||||
This plugin allows you to use the `webassets`_ module to manage assets such as
|
||||
CSS and JS files.
|
||||
|
||||
The ASSET_URL is set to a relative url to honor Pelican's RELATIVE_URLS
|
||||
setting. This requires the use of SITEURL in the templates::
|
||||
|
||||
<link rel="stylesheet" href="{{ SITEURL }}/{{ ASSET_URL }}">
|
||||
|
||||
.. _webassets: https://webassets.readthedocs.org/
|
||||
|
||||
"""
|
||||
|
||||
import os
|
||||
import logging
|
||||
|
||||
from pelican import signals
|
||||
from webassets import Environment
|
||||
from webassets.ext.jinja2 import AssetsExtension
|
||||
|
||||
|
||||
def add_jinja2_ext(pelican):
|
||||
"""Add Webassets to Jinja2 extensions in Pelican settings."""
|
||||
|
||||
pelican.settings['JINJA_EXTENSIONS'].append(AssetsExtension)
|
||||
|
||||
|
||||
def create_assets_env(generator):
|
||||
"""Define the assets environment and pass it to the generator."""
|
||||
|
||||
assets_url = 'theme/'
|
||||
assets_src = os.path.join(generator.output_path, 'theme')
|
||||
generator.env.assets_environment = Environment(assets_src, assets_url)
|
||||
|
||||
if 'ASSET_CONFIG' in generator.settings:
|
||||
for item in generator.settings['ASSET_CONFIG']:
|
||||
generator.env.assets_environment.config[item[0]] = item[1]
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
if logging.getLevelName(logger.getEffectiveLevel()) == "DEBUG":
|
||||
generator.env.assets_environment.debug = True
|
||||
|
||||
|
||||
def register():
|
||||
"""Plugin registration."""
|
||||
|
||||
signals.initialized.connect(add_jinja2_ext)
|
||||
signals.generator_init.connect(create_assets_env)
|
||||
|
|
@ -1,86 +0,0 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
from __future__ import unicode_literals, print_function
|
||||
"""
|
||||
Copyright (c) Marco Milanesi <kpanic@gnufunk.org>
|
||||
|
||||
A plugin to list your Github Activity
|
||||
To enable it set in your pelican config file the GITHUB_ACTIVITY_FEED
|
||||
parameter pointing to your github activity feed.
|
||||
|
||||
for example my personal activity feed is:
|
||||
|
||||
https://github.com/kpanic.atom
|
||||
|
||||
in your template just write a for in jinja2 syntax against the
|
||||
github_activity variable.
|
||||
|
||||
i.e.
|
||||
|
||||
<div class="social">
|
||||
<h2>Github Activity</h2>
|
||||
<ul>
|
||||
|
||||
{% for entry in github_activity %}
|
||||
<li><b>{{ entry[0] }}</b><br /> {{ entry[1] }}</li>
|
||||
{% endfor %}
|
||||
</ul>
|
||||
</div><!-- /.github_activity -->
|
||||
|
||||
github_activity is a list containing a list. The first element is the title
|
||||
and the second element is the raw html from github
|
||||
"""
|
||||
|
||||
from pelican import signals
|
||||
|
||||
|
||||
class GitHubActivity():
|
||||
"""
|
||||
A class created to fetch github activity with feedparser
|
||||
"""
|
||||
def __init__(self, generator):
|
||||
try:
|
||||
import feedparser
|
||||
self.activities = feedparser.parse(
|
||||
generator.settings['GITHUB_ACTIVITY_FEED'])
|
||||
except ImportError:
|
||||
raise Exception("Unable to find feedparser")
|
||||
|
||||
def fetch(self):
|
||||
"""
|
||||
returns a list of html snippets fetched from github actitivy feed
|
||||
"""
|
||||
|
||||
entries = []
|
||||
for activity in self.activities['entries']:
|
||||
entries.append(
|
||||
[element for element in [activity['title'],
|
||||
activity['content'][0]['value']]])
|
||||
|
||||
return entries
|
||||
|
||||
|
||||
def fetch_github_activity(gen, metadata):
|
||||
"""
|
||||
registered handler for the github activity plugin
|
||||
it puts in generator.context the html needed to be displayed on a
|
||||
template
|
||||
"""
|
||||
|
||||
if 'GITHUB_ACTIVITY_FEED' in gen.settings.keys():
|
||||
gen.context['github_activity'] = gen.plugin_instance.fetch()
|
||||
|
||||
|
||||
def feed_parser_initialization(generator):
|
||||
"""
|
||||
Initialization of feed parser
|
||||
"""
|
||||
|
||||
generator.plugin_instance = GitHubActivity(generator)
|
||||
|
||||
|
||||
def register():
|
||||
"""
|
||||
Plugin registration
|
||||
"""
|
||||
signals.article_generator_init.connect(feed_parser_initialization)
|
||||
signals.article_generate_context.connect(fetch_github_activity)
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
from pelican import signals
|
||||
|
||||
"""
|
||||
License plugin for Pelican
|
||||
==========================
|
||||
|
||||
This plugin allows you to define a LICENSE setting and adds the contents of that
|
||||
license variable to the article's context, making that variable available to use
|
||||
from within your theme's templates.
|
||||
|
||||
Settings:
|
||||
---------
|
||||
|
||||
Define LICENSE in your settings file with the contents of your default license.
|
||||
|
||||
"""
|
||||
|
||||
def add_license(generator, metadata):
|
||||
if 'license' not in metadata.keys()\
|
||||
and 'LICENSE' in generator.settings.keys():
|
||||
metadata['license'] = generator.settings['LICENSE']
|
||||
|
||||
def register():
|
||||
signals.article_generate_context.connect(add_license)
|
||||
|
|
@ -1,44 +0,0 @@
|
|||
import hashlib
|
||||
import six
|
||||
|
||||
from pelican import signals
|
||||
"""
|
||||
Gravatar plugin for Pelican
|
||||
===========================
|
||||
|
||||
This plugin assigns the ``author_gravatar`` variable to the Gravatar URL and
|
||||
makes the variable available within the article's context.
|
||||
|
||||
Settings:
|
||||
---------
|
||||
|
||||
Add AUTHOR_EMAIL to your settings file to define the default author's email
|
||||
address. Obviously, that email address must be associated with a Gravatar
|
||||
account.
|
||||
|
||||
Article metadata:
|
||||
------------------
|
||||
|
||||
:email: article's author email
|
||||
|
||||
If one of them are defined, the author_gravatar variable is added to the
|
||||
article's context.
|
||||
"""
|
||||
|
||||
def add_gravatar(generator, metadata):
|
||||
|
||||
#first check email
|
||||
if 'email' not in metadata.keys()\
|
||||
and 'AUTHOR_EMAIL' in generator.settings.keys():
|
||||
metadata['email'] = generator.settings['AUTHOR_EMAIL']
|
||||
|
||||
#then add gravatar url
|
||||
if 'email' in metadata.keys():
|
||||
email_bytes = six.b(metadata['email']).lower()
|
||||
gravatar_url = "http://www.gravatar.com/avatar/" + \
|
||||
hashlib.md5(email_bytes).hexdigest()
|
||||
metadata["author_gravatar"] = gravatar_url
|
||||
|
||||
|
||||
def register():
|
||||
signals.article_generate_context.connect(add_gravatar)
|
||||
|
|
@ -1,78 +0,0 @@
|
|||
# Copyright (c) 2012 Matt Layman
|
||||
'''A plugin to create .gz cache files for optimization.'''
|
||||
|
||||
import gzip
|
||||
import logging
|
||||
import os
|
||||
|
||||
from pelican import signals
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# A list of file types to exclude from possible compression
|
||||
EXCLUDE_TYPES = [
|
||||
# Compressed types
|
||||
'.bz2',
|
||||
'.gz',
|
||||
|
||||
# Audio types
|
||||
'.aac',
|
||||
'.flac',
|
||||
'.mp3',
|
||||
'.wma',
|
||||
|
||||
# Image types
|
||||
'.gif',
|
||||
'.jpg',
|
||||
'.jpeg',
|
||||
'.png',
|
||||
|
||||
# Video types
|
||||
'.avi',
|
||||
'.mov',
|
||||
'.mp4',
|
||||
]
|
||||
|
||||
def create_gzip_cache(pelican):
|
||||
'''Create a gzip cache file for every file that a webserver would
|
||||
reasonably want to cache (e.g., text type files).
|
||||
|
||||
:param pelican: The Pelican instance
|
||||
'''
|
||||
for dirpath, _, filenames in os.walk(pelican.settings['OUTPUT_PATH']):
|
||||
for name in filenames:
|
||||
if should_compress(name):
|
||||
filepath = os.path.join(dirpath, name)
|
||||
create_gzip_file(filepath)
|
||||
|
||||
def should_compress(filename):
|
||||
'''Check if the filename is a type of file that should be compressed.
|
||||
|
||||
:param filename: A file name to check against
|
||||
'''
|
||||
for extension in EXCLUDE_TYPES:
|
||||
if filename.endswith(extension):
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
def create_gzip_file(filepath):
|
||||
'''Create a gzipped file in the same directory with a filepath.gz name.
|
||||
|
||||
:param filepath: A file to compress
|
||||
'''
|
||||
compressed_path = filepath + '.gz'
|
||||
|
||||
with open(filepath, 'rb') as uncompressed:
|
||||
try:
|
||||
logger.debug('Compressing: %s' % filepath)
|
||||
compressed = gzip.open(compressed_path, 'wb')
|
||||
compressed.writelines(uncompressed)
|
||||
except Exception as ex:
|
||||
logger.critical('Gzip compression failed: %s' % ex)
|
||||
finally:
|
||||
compressed.close()
|
||||
|
||||
def register():
|
||||
signals.finalized.connect(create_gzip_cache)
|
||||
|
||||
|
|
@ -1,64 +0,0 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
from __future__ import unicode_literals
|
||||
from docutils import nodes
|
||||
from docutils.parsers.rst import directives, Directive
|
||||
|
||||
"""
|
||||
HTML tags for reStructuredText
|
||||
==============================
|
||||
|
||||
Directives
|
||||
----------
|
||||
|
||||
.. html::
|
||||
|
||||
(HTML code)
|
||||
|
||||
|
||||
Example
|
||||
-------
|
||||
|
||||
A search engine:
|
||||
|
||||
.. html::
|
||||
<form action="http://seeks.fr/search" method="GET">
|
||||
<input type="text" value="Pelican v2" title="Search" maxlength="2048" name="q" autocomplete="on" />
|
||||
<input type="hidden" name="lang" value="en" />
|
||||
<input type="submit" value="Seeks !" id="search_button" />
|
||||
</form>
|
||||
|
||||
|
||||
A contact form:
|
||||
|
||||
.. html::
|
||||
|
||||
<form method="GET" action="mailto:some email">
|
||||
<p>
|
||||
<input type="text" placeholder="Subject" name="subject">
|
||||
<br />
|
||||
<textarea name="body" placeholder="Message">
|
||||
</textarea>
|
||||
<br />
|
||||
<input type="reset"><input type="submit">
|
||||
</p>
|
||||
</form>
|
||||
|
||||
"""
|
||||
|
||||
|
||||
class RawHtml(Directive):
|
||||
required_arguments = 0
|
||||
optional_arguments = 0
|
||||
final_argument_whitespace = True
|
||||
has_content = True
|
||||
|
||||
def run(self):
|
||||
html = ' '.join(self.content)
|
||||
node = nodes.raw('', html, format='html')
|
||||
return [node]
|
||||
|
||||
|
||||
|
||||
def register():
|
||||
directives.register_directive('html', RawHtml)
|
||||
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
from __future__ import unicode_literals, print_function
|
||||
from pelican import signals
|
||||
|
||||
def test(sender):
|
||||
print("%s initialized !!" % sender)
|
||||
|
||||
def register():
|
||||
signals.initialized.connect(test)
|
||||
|
|
@ -1,35 +0,0 @@
|
|||
"""
|
||||
Related posts plugin for Pelican
|
||||
================================
|
||||
|
||||
Adds related_posts variable to article's context
|
||||
"""
|
||||
|
||||
from pelican import signals
|
||||
from collections import Counter
|
||||
|
||||
|
||||
def add_related_posts(generator):
|
||||
# get the max number of entries from settings
|
||||
# or fall back to default (5)
|
||||
numentries = generator.settings.get('RELATED_POSTS_MAX', 5)
|
||||
|
||||
for article in generator.articles:
|
||||
# no tag, no relation
|
||||
if not hasattr(article, 'tags'):
|
||||
continue
|
||||
|
||||
# score = number of common tags
|
||||
scores = Counter()
|
||||
for tag in article.tags:
|
||||
scores += Counter(generator.tags[tag])
|
||||
|
||||
# remove itself
|
||||
scores.pop(article)
|
||||
|
||||
article.related_posts = [other for other, count
|
||||
in scores.most_common(numentries)]
|
||||
|
||||
|
||||
def register():
|
||||
signals.article_generator_finalized.connect(add_related_posts)
|
||||
|
|
@ -1,195 +0,0 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
from __future__ import unicode_literals
|
||||
|
||||
import collections
|
||||
import os.path
|
||||
|
||||
from datetime import datetime
|
||||
from logging import warning, info
|
||||
from codecs import open
|
||||
|
||||
from pelican import signals, contents
|
||||
|
||||
TXT_HEADER = """{0}/index.html
|
||||
{0}/archives.html
|
||||
{0}/tags.html
|
||||
{0}/categories.html
|
||||
"""
|
||||
|
||||
XML_HEADER = """<?xml version="1.0" encoding="utf-8"?>
|
||||
<urlset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd"
|
||||
xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
|
||||
"""
|
||||
|
||||
XML_URL = """
|
||||
<url>
|
||||
<loc>{0}/{1}</loc>
|
||||
<lastmod>{2}</lastmod>
|
||||
<changefreq>{3}</changefreq>
|
||||
<priority>{4}</priority>
|
||||
</url>
|
||||
"""
|
||||
|
||||
XML_FOOTER = """
|
||||
</urlset>
|
||||
"""
|
||||
|
||||
|
||||
def format_date(date):
|
||||
if date.tzinfo:
|
||||
tz = date.strftime('%s')
|
||||
tz = tz[:-2] + ':' + tz[-2:]
|
||||
else:
|
||||
tz = "-00:00"
|
||||
return date.strftime("%Y-%m-%dT%H:%M:%S") + tz
|
||||
|
||||
|
||||
class SitemapGenerator(object):
|
||||
|
||||
def __init__(self, context, settings, path, theme, output_path, *null):
|
||||
|
||||
self.output_path = output_path
|
||||
self.context = context
|
||||
self.now = datetime.now()
|
||||
self.siteurl = settings.get('SITEURL')
|
||||
|
||||
self.format = 'xml'
|
||||
|
||||
self.changefreqs = {
|
||||
'articles': 'monthly',
|
||||
'indexes': 'daily',
|
||||
'pages': 'monthly'
|
||||
}
|
||||
|
||||
self.priorities = {
|
||||
'articles': 0.5,
|
||||
'indexes': 0.5,
|
||||
'pages': 0.5
|
||||
}
|
||||
|
||||
config = settings.get('SITEMAP', {})
|
||||
|
||||
if not isinstance(config, dict):
|
||||
warning("sitemap plugin: the SITEMAP setting must be a dict")
|
||||
else:
|
||||
fmt = config.get('format')
|
||||
pris = config.get('priorities')
|
||||
chfreqs = config.get('changefreqs')
|
||||
|
||||
if fmt not in ('xml', 'txt'):
|
||||
warning("sitemap plugin: SITEMAP['format'] must be `txt' or `xml'")
|
||||
warning("sitemap plugin: Setting SITEMAP['format'] on `xml'")
|
||||
elif fmt == 'txt':
|
||||
self.format = fmt
|
||||
return
|
||||
|
||||
valid_keys = ('articles', 'indexes', 'pages')
|
||||
valid_chfreqs = ('always', 'hourly', 'daily', 'weekly', 'monthly',
|
||||
'yearly', 'never')
|
||||
|
||||
if isinstance(pris, dict):
|
||||
# We use items for Py3k compat. .iteritems() otherwise
|
||||
for k, v in pris.items():
|
||||
if k in valid_keys and not isinstance(v, (int, float)):
|
||||
default = self.priorities[k]
|
||||
warning("sitemap plugin: priorities must be numbers")
|
||||
warning("sitemap plugin: setting SITEMAP['priorities']"
|
||||
"['{0}'] on {1}".format(k, default))
|
||||
pris[k] = default
|
||||
self.priorities.update(pris)
|
||||
elif pris is not None:
|
||||
warning("sitemap plugin: SITEMAP['priorities'] must be a dict")
|
||||
warning("sitemap plugin: using the default values")
|
||||
|
||||
if isinstance(chfreqs, dict):
|
||||
# .items() for py3k compat.
|
||||
for k, v in chfreqs.items():
|
||||
if k in valid_keys and v not in valid_chfreqs:
|
||||
default = self.changefreqs[k]
|
||||
warning("sitemap plugin: invalid changefreq `{0}'".format(v))
|
||||
warning("sitemap plugin: setting SITEMAP['changefreqs']"
|
||||
"['{0}'] on '{1}'".format(k, default))
|
||||
chfreqs[k] = default
|
||||
self.changefreqs.update(chfreqs)
|
||||
elif chfreqs is not None:
|
||||
warning("sitemap plugin: SITEMAP['changefreqs'] must be a dict")
|
||||
warning("sitemap plugin: using the default values")
|
||||
|
||||
|
||||
|
||||
def write_url(self, page, fd):
|
||||
|
||||
if getattr(page, 'status', 'published') != 'published':
|
||||
return
|
||||
|
||||
page_path = os.path.join(self.output_path, page.url)
|
||||
if not os.path.exists(page_path):
|
||||
return
|
||||
|
||||
lastmod = format_date(getattr(page, 'date', self.now))
|
||||
|
||||
if isinstance(page, contents.Article):
|
||||
pri = self.priorities['articles']
|
||||
chfreq = self.changefreqs['articles']
|
||||
elif isinstance(page, contents.Page):
|
||||
pri = self.priorities['pages']
|
||||
chfreq = self.changefreqs['pages']
|
||||
else:
|
||||
pri = self.priorities['indexes']
|
||||
chfreq = self.changefreqs['indexes']
|
||||
|
||||
|
||||
if self.format == 'xml':
|
||||
fd.write(XML_URL.format(self.siteurl, page.url, lastmod, chfreq, pri))
|
||||
else:
|
||||
fd.write(self.siteurl + '/' + loc + '\n')
|
||||
|
||||
|
||||
def generate_output(self, writer):
|
||||
path = os.path.join(self.output_path, 'sitemap.{0}'.format(self.format))
|
||||
|
||||
pages = self.context['pages'] + self.context['articles'] \
|
||||
+ [ c for (c, a) in self.context['categories']] \
|
||||
+ [ t for (t, a) in self.context['tags']] \
|
||||
+ [ a for (a, b) in self.context['authors']]
|
||||
|
||||
for article in self.context['articles']:
|
||||
pages += article.translations
|
||||
|
||||
info('writing {0}'.format(path))
|
||||
|
||||
with open(path, 'w', encoding='utf-8') as fd:
|
||||
|
||||
if self.format == 'xml':
|
||||
fd.write(XML_HEADER)
|
||||
else:
|
||||
fd.write(TXT_HEADER.format(self.siteurl))
|
||||
|
||||
FakePage = collections.namedtuple('FakePage',
|
||||
['status',
|
||||
'date',
|
||||
'url'])
|
||||
|
||||
for standard_page_url in ['index.html',
|
||||
'archives.html',
|
||||
'tags.html',
|
||||
'categories.html']:
|
||||
fake = FakePage(status='published',
|
||||
date=self.now,
|
||||
url=standard_page_url)
|
||||
self.write_url(fake, fd)
|
||||
|
||||
for page in pages:
|
||||
self.write_url(page, fd)
|
||||
|
||||
if self.format == 'xml':
|
||||
fd.write(XML_FOOTER)
|
||||
|
||||
|
||||
def get_generators(generators):
|
||||
return SitemapGenerator
|
||||
|
||||
|
||||
def register():
|
||||
signals.get_generators.connect(get_generators)
|
||||
|
|
@ -1,53 +0,0 @@
|
|||
import types
|
||||
|
||||
from pelican import signals
|
||||
|
||||
def initialized(pelican):
|
||||
from pelican.settings import _DEFAULT_CONFIG
|
||||
_DEFAULT_CONFIG.setdefault('SUMMARY_BEGIN_MARKER',
|
||||
'<!-- PELICAN_BEGIN_SUMMARY -->')
|
||||
_DEFAULT_CONFIG.setdefault('SUMMARY_END_MARKER',
|
||||
'<!-- PELICAN_END_SUMMARY -->')
|
||||
if pelican:
|
||||
pelican.settings.setdefault('SUMMARY_BEGIN_MARKER',
|
||||
'<!-- PELICAN_BEGIN_SUMMARY -->')
|
||||
pelican.settings.setdefault('SUMMARY_END_MARKER',
|
||||
'<!-- PELICAN_END_SUMMARY -->')
|
||||
|
||||
def content_object_init(instance):
|
||||
# if summary is already specified, use it
|
||||
if 'summary' in instance.metadata:
|
||||
return
|
||||
|
||||
def _get_content(self):
|
||||
content = self._content
|
||||
if self.settings['SUMMARY_BEGIN_MARKER']:
|
||||
content = content.replace(
|
||||
self.settings['SUMMARY_BEGIN_MARKER'], '', 1)
|
||||
if self.settings['SUMMARY_END_MARKER']:
|
||||
content = content.replace(
|
||||
self.settings['SUMMARY_END_MARKER'], '', 1)
|
||||
return content
|
||||
instance._get_content = types.MethodType(_get_content, instance)
|
||||
|
||||
# extract out our summary
|
||||
if not hasattr(instance, '_summary') and instance._content is not None:
|
||||
content = instance._content
|
||||
begin_summary = -1
|
||||
end_summary = -1
|
||||
if instance.settings['SUMMARY_BEGIN_MARKER']:
|
||||
begin_summary = content.find(instance.settings['SUMMARY_BEGIN_MARKER'])
|
||||
if instance.settings['SUMMARY_END_MARKER']:
|
||||
end_summary = content.find(instance.settings['SUMMARY_END_MARKER'])
|
||||
if begin_summary != -1 or end_summary != -1:
|
||||
# the beginning position has to take into account the length
|
||||
# of the marker
|
||||
begin_summary = (begin_summary +
|
||||
len(instance.settings['SUMMARY_BEGIN_MARKER'])
|
||||
if begin_summary != -1 else 0)
|
||||
end_summary = end_summary if end_summary != -1 else None
|
||||
instance._summary = content[begin_summary:end_summary]
|
||||
|
||||
def register():
|
||||
signals.initialized.connect(initialized)
|
||||
signals.content_object_init.connect(content_object_init)
|
||||
|
|
@ -1,101 +0,0 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
'''Core plugins unit tests'''
|
||||
|
||||
import os
|
||||
import tempfile
|
||||
|
||||
from pelican.contents import Page
|
||||
from pelican.plugins import gzip_cache
|
||||
|
||||
from pelican.tests.test_contents import TEST_CONTENT, TEST_SUMMARY
|
||||
from pelican.tests.support import unittest, temporary_folder
|
||||
|
||||
|
||||
class TestGzipCache(unittest.TestCase):
|
||||
|
||||
def test_should_compress(self):
|
||||
# Some filetypes should compress and others shouldn't.
|
||||
self.assertTrue(gzip_cache.should_compress('foo.html'))
|
||||
self.assertTrue(gzip_cache.should_compress('bar.css'))
|
||||
self.assertTrue(gzip_cache.should_compress('baz.js'))
|
||||
self.assertTrue(gzip_cache.should_compress('foo.txt'))
|
||||
|
||||
self.assertFalse(gzip_cache.should_compress('foo.gz'))
|
||||
self.assertFalse(gzip_cache.should_compress('bar.png'))
|
||||
self.assertFalse(gzip_cache.should_compress('baz.mp3'))
|
||||
self.assertFalse(gzip_cache.should_compress('foo.mov'))
|
||||
|
||||
def test_creates_gzip_file(self):
|
||||
# A file matching the input filename with a .gz extension is created.
|
||||
|
||||
# The plugin walks over the output content after the finalized signal
|
||||
# so it is safe to assume that the file exists (otherwise walk would
|
||||
# not report it). Therefore, create a dummy file to use.
|
||||
with temporary_folder() as tempdir:
|
||||
_, a_html_filename = tempfile.mkstemp(suffix='.html', dir=tempdir)
|
||||
gzip_cache.create_gzip_file(a_html_filename)
|
||||
self.assertTrue(os.path.exists(a_html_filename + '.gz'))
|
||||
|
||||
|
||||
class TestSummary(unittest.TestCase):
|
||||
def setUp(self):
|
||||
super(TestSummary, self).setUp()
|
||||
|
||||
from pelican.plugins import summary
|
||||
|
||||
summary.register()
|
||||
summary.initialized(None)
|
||||
self.page_kwargs = {
|
||||
'content': TEST_CONTENT,
|
||||
'context': {
|
||||
'localsiteurl': '',
|
||||
},
|
||||
'metadata': {
|
||||
'summary': TEST_SUMMARY,
|
||||
'title': 'foo bar',
|
||||
'author': 'Blogger',
|
||||
},
|
||||
}
|
||||
|
||||
def _copy_page_kwargs(self):
|
||||
# make a deep copy of page_kwargs
|
||||
page_kwargs = dict([(key, self.page_kwargs[key]) for key in
|
||||
self.page_kwargs])
|
||||
for key in page_kwargs:
|
||||
if not isinstance(page_kwargs[key], dict):
|
||||
break
|
||||
page_kwargs[key] = dict([(subkey, page_kwargs[key][subkey])
|
||||
for subkey in page_kwargs[key]])
|
||||
|
||||
return page_kwargs
|
||||
|
||||
def test_end_summary(self):
|
||||
page_kwargs = self._copy_page_kwargs()
|
||||
del page_kwargs['metadata']['summary']
|
||||
page_kwargs['content'] = (
|
||||
TEST_SUMMARY + '<!-- PELICAN_END_SUMMARY -->' + TEST_CONTENT)
|
||||
page = Page(**page_kwargs)
|
||||
# test both the summary and the marker removal
|
||||
self.assertEqual(page.summary, TEST_SUMMARY)
|
||||
self.assertEqual(page.content, TEST_SUMMARY + TEST_CONTENT)
|
||||
|
||||
def test_begin_summary(self):
|
||||
page_kwargs = self._copy_page_kwargs()
|
||||
del page_kwargs['metadata']['summary']
|
||||
page_kwargs['content'] = (
|
||||
'FOOBAR<!-- PELICAN_BEGIN_SUMMARY -->' + TEST_CONTENT)
|
||||
page = Page(**page_kwargs)
|
||||
# test both the summary and the marker removal
|
||||
self.assertEqual(page.summary, TEST_CONTENT)
|
||||
self.assertEqual(page.content, 'FOOBAR' + TEST_CONTENT)
|
||||
|
||||
def test_begin_end_summary(self):
|
||||
page_kwargs = self._copy_page_kwargs()
|
||||
del page_kwargs['metadata']['summary']
|
||||
page_kwargs['content'] = (
|
||||
'FOOBAR<!-- PELICAN_BEGIN_SUMMARY -->' + TEST_SUMMARY +
|
||||
'<!-- PELICAN_END_SUMMARY -->' + TEST_CONTENT)
|
||||
page = Page(**page_kwargs)
|
||||
# test both the summary and the marker removal
|
||||
self.assertEqual(page.summary, TEST_SUMMARY)
|
||||
self.assertEqual(page.content, 'FOOBAR' + TEST_SUMMARY + TEST_CONTENT)
|
||||
|
|
@ -1,106 +0,0 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# from __future__ import unicode_literals
|
||||
|
||||
import hashlib
|
||||
import locale
|
||||
import os
|
||||
from codecs import open
|
||||
from tempfile import mkdtemp
|
||||
from shutil import rmtree
|
||||
|
||||
from pelican import Pelican
|
||||
from pelican.settings import read_settings
|
||||
from .support import unittest, skipIfNoExecutable, module_exists
|
||||
|
||||
CUR_DIR = os.path.dirname(__file__)
|
||||
THEME_DIR = os.path.join(CUR_DIR, 'themes', 'assets')
|
||||
CSS_REF = open(os.path.join(THEME_DIR, 'static', 'css',
|
||||
'style.min.css')).read()
|
||||
CSS_HASH = hashlib.md5(CSS_REF).hexdigest()[0:8]
|
||||
|
||||
|
||||
@unittest.skipUnless(module_exists('webassets'), "webassets isn't installed")
|
||||
@skipIfNoExecutable(['scss', '-v'])
|
||||
@skipIfNoExecutable(['cssmin', '--version'])
|
||||
class TestWebAssets(unittest.TestCase):
|
||||
"""Base class for testing webassets."""
|
||||
|
||||
def setUp(self, override=None):
|
||||
self.temp_path = mkdtemp(prefix='pelicantests.')
|
||||
settings = {
|
||||
'PATH': os.path.join(CUR_DIR, 'content', 'TestCategory'),
|
||||
'OUTPUT_PATH': self.temp_path,
|
||||
'PLUGINS': ['pelican.plugins.assets', ],
|
||||
'THEME': THEME_DIR,
|
||||
'LOCALE': locale.normalize('en_US'),
|
||||
}
|
||||
if override:
|
||||
settings.update(override)
|
||||
|
||||
self.settings = read_settings(override=settings)
|
||||
pelican = Pelican(settings=self.settings)
|
||||
pelican.run()
|
||||
|
||||
def tearDown(self):
|
||||
rmtree(self.temp_path)
|
||||
|
||||
def check_link_tag(self, css_file, html_file):
|
||||
"""Check the presence of `css_file` in `html_file`."""
|
||||
|
||||
link_tag = ('<link rel="stylesheet" href="{css_file}">'
|
||||
.format(css_file=css_file))
|
||||
html = open(html_file).read()
|
||||
self.assertRegexpMatches(html, link_tag)
|
||||
|
||||
|
||||
class TestWebAssetsRelativeURLS(TestWebAssets):
|
||||
"""Test pelican with relative urls."""
|
||||
|
||||
def setUp(self):
|
||||
TestWebAssets.setUp(self, override={'RELATIVE_URLS': True})
|
||||
|
||||
def test_jinja2_ext(self):
|
||||
# Test that the Jinja2 extension was correctly added.
|
||||
|
||||
from webassets.ext.jinja2 import AssetsExtension
|
||||
self.assertIn(AssetsExtension, self.settings['JINJA_EXTENSIONS'])
|
||||
|
||||
def test_compilation(self):
|
||||
# Compare the compiled css with the reference.
|
||||
|
||||
gen_file = os.path.join(self.temp_path, 'theme', 'gen',
|
||||
'style.{0}.min.css'.format(CSS_HASH))
|
||||
self.assertTrue(os.path.isfile(gen_file))
|
||||
|
||||
css_new = open(gen_file).read()
|
||||
self.assertEqual(css_new, CSS_REF)
|
||||
|
||||
def test_template(self):
|
||||
# Look in the output files for the link tag.
|
||||
|
||||
css_file = './theme/gen/style.{0}.min.css'.format(CSS_HASH)
|
||||
html_files = ['index.html', 'archives.html',
|
||||
'this-is-an-article-with-category.html']
|
||||
for f in html_files:
|
||||
self.check_link_tag(css_file, os.path.join(self.temp_path, f))
|
||||
|
||||
self.check_link_tag(
|
||||
'../theme/gen/style.{0}.min.css'.format(CSS_HASH),
|
||||
os.path.join(self.temp_path, 'category/yeah.html'))
|
||||
|
||||
|
||||
class TestWebAssetsAbsoluteURLS(TestWebAssets):
|
||||
"""Test pelican with absolute urls."""
|
||||
|
||||
def setUp(self):
|
||||
TestWebAssets.setUp(self, override={'SITEURL': 'http://localhost'})
|
||||
|
||||
def test_absolute_url(self):
|
||||
# Look in the output files for the link tag with absolute url.
|
||||
|
||||
css_file = ('http://localhost/theme/gen/style.{0}.min.css'
|
||||
.format(CSS_HASH))
|
||||
html_files = ['index.html', 'archives.html',
|
||||
'this-is-an-article-with-category.html']
|
||||
for f in html_files:
|
||||
self.check_link_tag(css_file, os.path.join(self.temp_path, f))
|
||||
|
|
@ -1 +0,0 @@
|
|||
body{font:14px/1.5 "Droid Sans",sans-serif;background-color:#e4e4e4;color:#242424}a{color:red}a:hover{color:orange}
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
/* -*- scss-compile-at-save: nil -*- */
|
||||
|
||||
$baseFontFamily : "Droid Sans", sans-serif;
|
||||
$textColor : #242424;
|
||||
$bodyBackground : #e4e4e4;
|
||||
|
||||
body {
|
||||
font: 14px/1.5 $baseFontFamily;
|
||||
background-color: $bodyBackground;
|
||||
color: $textColor;
|
||||
}
|
||||
|
||||
a {
|
||||
color: red;
|
||||
|
||||
&:hover {
|
||||
color: orange;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
{% extends "!simple/base.html" %}
|
||||
|
||||
{% block head %}
|
||||
{% assets filters="scss,cssmin", output="gen/style.%(version)s.min.css", "css/style.scss" %}
|
||||
<link rel="stylesheet" href="{{ SITEURL }}/{{ ASSET_URL }}">
|
||||
{% endassets %}
|
||||
{% endblock %}
|
||||
Loading…
Add table
Add a link
Reference in a new issue