def test_markdown_extensions(self):
pages = FlatPages(Flask(__name__))
hello = pages.get('headerid')
self.assertEqual(
hello.html,
u'<h1>Page Header</h1>\n<h2>Paragraph Header</h2>\n<p>Text</p>'
)
pages.app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = []
pages.reload()
pages._file_cache = {}
hello = pages.get('headerid')
self.assertEqual(
hello.html,
u'<h1>Page Header</h1>\n<h2>Paragraph Header</h2>\n<p>Text</p>'
)
pages.app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = [
'codehilite', 'headerid'
]
pages.reload()
pages._file_cache = {}
hello = pages.get('headerid')
self.assertEqual(
hello.html,
'<h1 id="page-header">Page Header</h1>\n'
'<h2 id="paragraph-header">Paragraph Header</h2>\n'
'<p>Text</p>'
)
def test_other_html_renderer(self):
def body_renderer(body):
return body.upper()
def page_renderer(body, pages, page):
return page.body.upper()
def pages_renderer(body, pages):
return pages.get('hello').body.upper()
renderers = filter(None, (
operator.methodcaller('upper'),
'string.upper' if not compat.IS_PY3 else None,
body_renderer,
page_renderer,
pages_renderer
))
for renderer in (renderers):
pages = FlatPages(Flask(__name__))
pages.app.config['FLATPAGES_HTML_RENDERER'] = renderer
hello = pages.get('hello')
self.assertEqual(hello.body, u'Hello, *世界*!\n')
# Upper-case, markdown not interpreted
self.assertEqual(hello.html, u'HELLO, *世界*!\n')
def test_yaml_meta(self):
pages = FlatPages(Flask(__name__))
foo = pages.get('foo')
self.assertEqual(foo.meta, {
'title': 'Foo > bar',
'created': datetime.date(2010, 12, 11),
'versions': [3.14, 42]
})
self.assertEqual(foo['title'], 'Foo > bar')
self.assertEqual(foo['created'], datetime.date(2010, 12, 11))
self.assertEqual(foo['versions'], [3.14, 42])
self.assertRaises(KeyError, lambda: foo['nonexistent'])
def test_yaml_meta(self):
pages = FlatPages(Flask(__name__))
foo = pages.get('foo')
self.assertEqual(
foo.meta, {
'title': 'Foo > bar',
'created': datetime.date(2010, 12, 11),
'versions': [3.14, 42]
})
self.assertEqual(foo['title'], 'Foo > bar')
self.assertEqual(foo['created'], datetime.date(2010, 12, 11))
self.assertEqual(foo['versions'], [3.14, 42])
self.assertRaises(KeyError, lambda: foo['nonexistent'])
def test_markdown_extensions_codehilite_linenums_disabled(self):
app = Flask(__name__)
app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = [
'codehilite(linenums=False)'
]
pages = FlatPages(app)
codehilite = pages.get('codehilite')
self.assertEqual(
codehilite.html,
'<div class="codehilite"><pre><span class="k">print</span>'
'<span class="p">(</span><span class="s">'Hello, world!''
'</span><span class="p">)</span>\n</pre></div>'
)
def test_markdown_extensions_toc(self):
app = Flask(__name__)
app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = ['toc']
pages = FlatPages(app)
toc = pages.get('toc')
self.assertEqual(
toc.html,
'<div class="toc">\n<ul>\n<li><a href="#page-header">Page '
'Header</a><ul>\n<li><a href="#paragraph-header">Paragraph '
'Header</a></li>\n</ul>\n</li>\n</ul>\n</div>\n'
'<h1 id="page-header">Page Header</h1>\n'
'<h2 id="paragraph-header">Paragraph Header</h2>\n'
'<p>Text</p>'
)
class CategorizedFlatPages:
def __init__(self):
self.flat_pages = FlatPages()
self.root_category = Category(None, '<root>')
def init_app(self, app):
self.flat_pages.init_app(app)
self._set_categories()
def __iter__(self):
return iter(
sorted(self.root_category.categories.values(),
key=attrgetter('rank')))
def get(self, category_id, article_id):
category = self.root_category.categories.get(category_id)
if category is None:
return None
return category.articles.get(article_id)
def get_articles_of_category(self, category_id):
barticles = []
category = self.root_category.categories.get(category_id)
if category:
for a in list(category.articles.values()):
if a.id != 'index':
barticles.append(a)
return barticles
def get_or_404(self, category_id, article_id):
page = self.get(category_id, article_id)
if page is None:
abort(404)
return page
def _set_categories(self):
for page in self.flat_pages:
components = page.path.split('/')
parent = self.root_category
for category_id in components[:-1]:
parent = parent.add_category(category_id)
page_name = components[-1]
parent.add_article(page_name, page)
def reload(self):
self.flat_pages.reload()
self._set_categories()
class CategorizedFlatPages:
def __init__(self):
self.flat_pages = FlatPages()
self.root_category = Category(None, '<root>')
def init_app(self, app):
self.flat_pages.init_app(app)
self._set_categories()
def __iter__(self):
return iter(sorted(self.root_category.categories.values(),
key=attrgetter('rank')))
def get(self, category_id, article_id):
category = self.root_category.categories.get(category_id)
if category is None:
return None
return category.articles.get(article_id)
def get_articles_of_category(self, category_id):
barticles = []
category = self.root_category.categories.get(
category_id)
if category:
for a in list(category.articles.values()):
if a.id != 'index':
barticles.append(a)
return barticles
def get_or_404(self, category_id, article_id):
page = self.get(category_id, article_id)
if page is None:
abort(404)
return page
def _set_categories(self):
for page in self.flat_pages:
components = page.path.split('/')
parent = self.root_category
for category_id in components[:-1]:
parent = parent.add_category(category_id)
page_name = components[-1]
parent.add_article(page_name, page)
def reload(self):
self.flat_pages.reload()
self._set_categories()
def test_iter(self):
pages = FlatPages(Flask(__name__))
self.assertEqual(
set(page.path for page in pages),
set([
'codehilite', 'extra', 'foo', 'foo/bar', 'foo/lorem/ipsum',
'headerid', 'hello', 'toc'
]))
def create_app(**options):
"""
Initialize Flask application and FlatPages extension.
"""
app = Flask(__name__)
app.config.update(options)
pages = FlatPages(app)
return (app, pages)
def test_extension_sequence(self, extension=None):
app = Flask(__name__)
app.config['FLATPAGES_EXTENSION'] = extension or ['.html', '.txt']
pages = FlatPages(app)
self.assertEqual(
set(page.path for page in pages),
set([
'codehilite', 'extra', 'foo', 'foo/42/not_a_page', 'foo/bar',
'foo/lorem/ipsum', 'headerid', 'hello', 'not_a_page', 'toc'
]))
def test_other_html_renderer(self):
def body_renderer(body):
return body.upper()
def page_renderer(body, pages, page):
return page.body.upper()
def pages_renderer(body, pages):
return pages.get('hello').body.upper()
renderers = filter(None,
(operator.methodcaller('upper'),
'string.upper' if not compat.IS_PY3 else None,
body_renderer, page_renderer, pages_renderer))
for renderer in (renderers):
pages = FlatPages(Flask(__name__))
pages.app.config['FLATPAGES_HTML_RENDERER'] = renderer
hello = pages.get('hello')
self.assertEqual(hello.body, u'Hello, *世界*!\n')
# Upper-case, markdown not interpreted
self.assertEqual(hello.html, u'HELLO, *世界*!\n')
def temp_pages(app=None, name=None):
"""This context manager gives a FlatPages object configured
in a temporary directory with a copy of the test pages.
Using a temporary copy allows us to safely write and remove stuff without
worrying about undoing our changes.
"""
with temp_directory() as temp:
source = os.path.join(os.path.dirname(__file__), 'pages')
# Remove the destination dir as copytree wants it not to exist.
# Doing so kind of defeats the purpose of tempfile as it introduces
# a race condition, but should be good enough for our purpose.
os.rmdir(temp)
shutil.copytree(source, temp)
app = app or Flask(__name__)
if name is None:
config_root = 'FLATPAGES_ROOT'
else:
config_root = 'FLATPAGES_%s_ROOT' % str(name).upper()
app.config[config_root] = temp
yield FlatPages(app, name)
def setup(app):
db.init_app(app)
mail.init_app(app)
#login_manager.init_app(app)
admin = Admin(app)
bootstrap = Bootstrap(app)
app.register_plugin("website.security")
setup_filters_and_processors(app)
app.register_plugin("website.views")
#app.register_plugin("website.cfp")
app.register_plugin("website.registration")
app.register_plugin("website.crm")
app.register_plugin("website.sdc") # Students demo cup
# Add some extensions
whoosh = Whoosh(app)
pages = FlatPages(app)
app.extensions['pages'] = pages
setup_freezer(app)
markdown_manager = Markdown(app)
asset_manager = AssetManager(app)
app.extensions['asset_manager'] = asset_manager
# Setup custome babel config (see below)
setup_babel(app)
# Setup hierarchical Jinja2 template loader
# TODO: should be generic
setup_template_loader(app)
create_db(app)
load_tracks(app)
if not app.config.get('TESTING'):
pass
def test_get(self):
pages = FlatPages(Flask(__name__))
self.assertEqual(pages.get('foo/bar').path, 'foo/bar')
self.assertEqual(pages.get('nonexistent'), None)
self.assertEqual(pages.get('nonexistent', 42), 42)
def test_consistency(self):
pages = FlatPages(Flask(__name__))
for page in pages:
assert pages.get(page.path) is page
def test_markdown(self):
pages = FlatPages(Flask(__name__))
foo = pages.get('foo')
self.assertEqual(foo.body, 'Foo *bar*\n')
self.assertEqual(foo.html, '<p>Foo <em>bar</em></p>')
def test_get(self):
pages = FlatPages(Flask(__name__))
self.assertEqual(pages.get('foo/bar').path, 'foo/bar')
self.assertEqual(pages.get('nonexistent'), None)
self.assertEqual(pages.get('nonexistent', 42), 42)
def test_get_or_404(self):
pages = FlatPages(Flask(__name__))
self.assertEqual(pages.get_or_404('foo/bar').path, 'foo/bar')
self.assertRaises(NotFound, pages.get_or_404, 'nonexistent')
def test_unicode(self):
pages = FlatPages(Flask(__name__))
self._unicode(pages)
def __init__(self):
self.flat_pages = FlatPages()
self.root_category = Category(None, '<root>')
def test_other_encoding(self):
app = Flask(__name__)
app.config['FLATPAGES_ENCODING'] = 'shift_jis'
app.config['FLATPAGES_ROOT'] = 'pages_shift_jis'
pages = FlatPages(app)
self._unicode(pages)
from flask import Flask
from flask.ext.flatpages import FlatPages
from flask.ext.frozen import Freezer
from flask.ext.bootstrap import Bootstrap
from config import config
pages = FlatPages()
freezer = Freezer()
bootstrap = Bootstrap()
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
freezer.init_app(app)
pages.init_app(app)
bootstrap.init_app(app)
#register blueprints:
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
return app
from solr import SolrConnection
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.flatpages import FlatPages
from flask.ext.mail import Mail
from offenesparlament import default_settings
app = Flask(__name__)
app.config.from_object(default_settings)
app.config.from_envvar('PARLAMENT_SETTINGS', silent=True)
db = SQLAlchemy(app)
pages = FlatPages(app)
mail = Mail(app)
def solr():
return SolrConnection(app.config['SOLR_URL'],
http_user=app.config.get('SOLR_USER'),
http_pass=app.config.get('SOLR_PASSWORD'))
def etl_engine():
from sqlaload import connect
return connect(app.config['ETL_URL'])
def archive_path(*a):
def __init__(self):
self.flat_pages = FlatPages()
self.root_category = Category(None, '<root>')
app.config.from_pyfile(os.path.join(os.getcwd(), 'config.py'))
except IOError:
print 'Can not find config.py'
sys.exit()
# To avoid full paths in config.py
app.config['FLATPAGES_ROOT'] = os.path.join(os.getcwd(),
app.config.get('POSTS_FOLDER'))
app.config['FREEZER_DESTINATION'] = os.path.join(
os.getcwd(), app.config.get('BUILD_FOLDER'))
app.config['FLATPAGES_EXTENSION'] = app.config.get('POSTS_EXTENSION')
app.config['INCLUDE_JS'] = 'combined.min.js' in os.listdir(app.static_folder)
app.config['INCLUDE_CSS'] = 'combined.min.css' in os.listdir(app.static_folder)
posts = FlatPages(app)
freezer = Freezer(app)
# Allow config settings (even new user created ones) to be used in templates
for key in app.config:
app.jinja_env.globals[key] = app.config[key]
def truncate_post_html(post_html):
return BeautifulSoup(post_html[:255]).prettify()
app.jinja_env.globals['truncate_post_html'] = truncate_post_html
app.jinja_loader = ChoiceLoader([
FileSystemLoader(os.path.join(os.getcwd(), 'templates/')), app.jinja_loader
def test_other_extension(self):
app = Flask(__name__)
app.config['FLATPAGES_EXTENSION'] = '.txt'
pages = FlatPages(app)
self.assertEqual(set(page.path for page in pages),
set(['not_a_page', 'foo/42/not_a_page']))
def test_markdown_extensions(self):
pages = FlatPages(Flask(__name__))
hello = pages.get('headerid')
self.assertEqual(
hello.html,
u'<h1>Page Header</h1>\n<h2>Paragraph Header</h2>\n<p>Text</p>')
pages.app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = []
pages.reload()
pages._file_cache = {}
hello = pages.get('headerid')
self.assertEqual(
hello.html,
u'<h1>Page Header</h1>\n<h2>Paragraph Header</h2>\n<p>Text</p>')
pages.app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = [
'codehilite', 'headerid'
]
pages.reload()
pages._file_cache = {}
hello = pages.get('headerid')
self.assertEqual(
hello.html, u'<h1 id="page-header">Page Header</h1>\n'
u'<h2 id="paragraph-header">Paragraph Header</h2>\n'
u'<p>Text</p>')
def test_consistency(self):
pages = FlatPages(Flask(__name__))
for page in pages:
assert pages.get(page.path) is page
def test_get_or_404(self):
pages = FlatPages(Flask(__name__))
self.assertEqual(pages.get_or_404('foo/bar').path, 'foo/bar')
self.assertRaises(NotFound, pages.get_or_404, 'nonexistent')
class CategorizedFlatPages:
"""The main interface to gather pages and categories
* What is it used for?
- Looping: E.g. In the navbar
- get news → get_articles_of_category('news')
- get static page → get_or_404()
"""
def __init__(self):
self.flat_pages = FlatPages()
self.root_category = Category(None, '<root>')
def init_app(self, app):
self.flat_pages.init_app(app)
self._init_categories()
@property
def categories(self):
"""Yield all categories as an iterable
"""
return sorted(self.root_category.categories.values(),
key=attrgetter('rank'))
def get(self, category_id, article_id):
category = self.root_category.categories.get(category_id)
if category is None:
return None
return category._articles.get(article_id)
def get_category(self, category_id):
"""Return the `Category` object from a given name (id)
"""
return self.root_category.categories.get(category_id)
def get_articles_of_category(self, category_id):
"""Get the articles of a category
- ONLY used for fetching news
"""
articles = []
category = self.get_category(category_id)
if category:
for a in category._articles.values():
if a.id != 'index':
articles.append(a)
return articles
def get_or_404(self, category_id, article_id):
"""Fetch a static page"""
page = self.get(category_id, article_id)
if page is None:
abort(404)
return page
def _init_categories(self):
# TODO: Store categories, not articles
for page in self.flat_pages:
# get category + page name
# plus, assert that there is nothing more to that.
components = page.path.split('/')
parent = self.root_category
for category_id in components[:-1]:
parent = parent.add_child_category(category_id)
basename = components[-1]
parent.add_article(basename, page)
def reload(self):
self.flat_pages.reload()
self._init_categories()
def test_markdown(self):
pages = FlatPages(Flask(__name__))
foo = pages.get('foo')
self.assertEqual(foo.body, 'Foo *bar*\n')
self.assertEqual(foo.html, '<p>Foo <em>bar</em></p>')
