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_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):
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>')
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()