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_basic(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):
for renderer in (unicode.upper, 'string.upper'):
pages = FlatPages(Flask(__name__))
pages.app.config['FLATPAGES_HTML_RENDERER'] = renderer
hello = pages.get('hello')
self.assertEquals(hello.body, u'Hello, *世界*!\n')
# Upper-case, markdown not interpreted
self.assertEquals(hello.html, u'HELLO, *世界*!\n')
def test_other_html_renderer(self):
for renderer in (unicode.upper, 'string.upper'):
pages = FlatPages(Flask(__name__))
pages.app.config['FLATPAGES_HTML_RENDERER'] = renderer
hello = pages.get('hello')
self.assertEquals(hello.body, u'Hello, *世界*!\n')
# Upper-case, markdown not interpreted
self.assertEquals(hello.html, u'HELLO, *世界*!\n')
def test_html_conversion(self):
pages = FlatPages(Flask(__name__))
foo = pages.get("foo")
print "we get here"
print foo["description_html"]
self.assertTrue(True)
self.assertEquals(foo["description"].strip(), '# hello')
self.assertEquals(foo["description_html"], '<h1>hello</h1>')
def test_instance_relative(self):
with temp_directory() as temp:
source = os.path.join(os.path.dirname(__file__), 'pages')
dest = os.path.join(temp, 'instance', 'pages')
shutil.copytree(source, dest)
app = Flask(__name__, instance_path=os.path.join(temp, 'instance'))
app.config['FLATPAGES_INSTANCE_RELATIVE'] = True
pages = FlatPages(app)
bar = pages.get('foo/bar')
self.assertTrue(bar is not None)
def test_instance_relative(self):
with temp_directory() as temp:
source = os.path.join(os.path.dirname(__file__), 'pages')
dest = os.path.join(temp, 'instance', 'pages')
shutil.copytree(source, dest)
app = Flask(__name__, instance_path=os.path.join(temp, 'instance'))
app.config['FLATPAGES_INSTANCE_RELATIVE'] = True
pages = FlatPages(app)
bar = pages.get('foo/bar')
self.assertTrue(bar is not None)
def test_yaml_meta(self):
pages = FlatPages(Flask(__name__))
foo = pages.get('foo')
self.assertEquals(foo.meta, {
'title': 'Foo > bar',
'created': datetime.date(2010, 12, 11),
'versions': [3.14, 42]
})
self.assertEquals(foo['title'], 'Foo > bar')
self.assertEquals(foo['created'], datetime.date(2010, 12, 11))
self.assertEquals(foo['versions'], [3.14, 42])
self.assertRaises(KeyError, lambda: foo['nonexistent'])
def test_extra(self):
app = Flask(__name__)
app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = ['extra']
pages = FlatPages(app)
extra_sep = '\n' if sys.version_info[:2] > (2, 6) else '\n\n'
extra = pages.get('extra')
self.assertEqual(
extra.html, '<p>This is <em>true</em> markdown text.</p>\n'
'<div>{0}'
'<p>This is <em>true</em> markdown text.</p>\n'
'</div>'.format(extra_sep))
def test_extension_object(self):
app = Flask(__name__)
from markdown.extensions.codehilite import CodeHiliteExtension
codehilite = CodeHiliteExtension()
app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = [codehilite]
pages = FlatPages(app)
self.check_default_codehilite_page(pages)
codehilite = CodeHiliteExtension(linenums='True') #Check config applies
app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = [codehilite]
pages.reload()
pages._file_cache = {}
self.check_codehilite_with_linenums(pages)
def test_yaml_meta(self):
pages = FlatPages(Flask(__name__))
foo = pages.get('foo')
self.assertEquals(
foo.meta, {
'title': 'Foo > bar',
'created': datetime.date(2010, 12, 11),
'versions': [3.14, 42]
})
self.assertEquals(foo['title'], 'Foo > bar')
self.assertEquals(foo['created'], datetime.date(2010, 12, 11))
self.assertEquals(foo['versions'], [3.14, 42])
self.assertRaises(KeyError, lambda: foo['nonexistent'])
def test_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_extension_object(self):
app = Flask(__name__)
from markdown.extensions.codehilite import CodeHiliteExtension
codehilite = CodeHiliteExtension()
app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = [codehilite]
pages = FlatPages(app)
self.check_default_codehilite_page(pages)
codehilite = CodeHiliteExtension(
linenums='True') #Check config applies
app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = [codehilite]
pages.reload()
pages._file_cache = {}
self.check_codehilite_with_linenums(pages)
def test_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_extra(self):
app = Flask(__name__)
app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = ['extra']
pages = FlatPages(app)
extra_sep = '\n' if sys.version_info[:2] > (2, 6) else '\n\n'
extra = pages.get('extra')
self.assertEqual(
extra.html,
'<p>This is <em>true</em> markdown text.</p>\n'
'<div>{0}'
'<p>This is <em>true</em> markdown text.</p>\n'
'</div>'.format(extra_sep)
)
def test_codehilite_linenums_disabled(self):
#Test explicity disabled
app = Flask(__name__)
app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = ['codehilite']
pages = FlatPages(app)
self.check_default_codehilite_page(pages)
#Test explicity disabled
pages.app.config['FLATPAGES_EXTENSION_CONFIGS'] = {
'codehilite': {
'linenums': 'False'
}
}
pages.reload()
pages._file_cache = {}
self.check_default_codehilite_page(pages)
def test_extension_importpath(self):
app = Flask(__name__)
app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = [
'markdown.extensions.codehilite:CodeHiliteExtension'
]
pages = FlatPages(app)
self.check_default_codehilite_page(pages)
app.config['FLATPAGES_EXTENSION_CONFIGS'] = { #Markdown 3 style config
'markdown.extensions.codehilite:CodeHiliteExtension': {
'linenums': True
}
}
pages.reload()
pages._file_cache = {}
self.check_codehilite_with_linenums(pages)
def test_codehilite_linenums_disabled(self):
#Test explicity disabled
app = Flask(__name__)
app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = ['codehilite']
pages = FlatPages(app)
self.check_default_codehilite_page(pages)
#Test explicity disabled
pages.app.config['FLATPAGES_EXTENSION_CONFIGS'] = {
'codehilite': {
'linenums': 'False'
}
}
pages.reload()
pages._file_cache = {}
self.check_default_codehilite_page(pages)
def test_extension_importpath(self):
app = Flask(__name__)
app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = [
'markdown.extensions.codehilite:CodeHiliteExtension'
]
pages = FlatPages(app)
self.check_default_codehilite_page(pages)
app.config['FLATPAGES_EXTENSION_CONFIGS'] = { #Markdown 3 style config
'markdown.extensions.codehilite:CodeHiliteExtension': {
'linenums': True
}
}
pages.reload()
pages._file_cache = {}
self.check_codehilite_with_linenums(pages)
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(config_class)
pages = FlatPages(app)
freezer = Freezer(app)
jsglue = JSGlue(app)
bootstrap.init_app(app)
from app.core import bp as core_bp
app.register_blueprint(core_bp)
if not app.debug:
if not os.path.exists('logs'):
os.mkdir('logs')
file_handler = RotatingFileHandler('logs/endless_farming.log', maxBytes=10240,
backupCount=10)
file_handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'))
file_handler.setLevel(logging.INFO)
app.logger.addHandler(file_handler)
app.logger.setLevel(logging.INFO)
app.logger.info('Endless farming startup')
return app, freezer, pages
def page(path):
page = pages.get_or_404(path)
if request.method == "POST" and "user_id" in session:
page_fullpath = (Path() / app.config["FLASK_APP"] /
app.config["FLATPAGES_ROOT"] /
secure_filename(page.path + ".md"))
try:
page_fullpath.unlink()
FlatPages.reload(pages)
flash(f"Blog post {page.path} has been deleted!", "Info")
return redirect(url_for("index"))
except OSError:
abort(404)
return render_template("page.j2", page=page)
class TestFlatPagesPandoc(unittest.TestCase):
def setUp(self):
self.tmp = mkdtemp()
self.content = os.path.join(self.tmp, "content")
os.makedirs(self.content)
self.app = Flask(__name__)
self.app.config.update(
FLATPAGES_ROOT=self.content,
FLATPAGES_ENCODING="utf-8",
FLATPAGES_AUTO_RELOAD=True,
)
self.pages = FlatPages(self.app)
FlatPagesPandoc("markdown", self.app, pre_render=False)
def tearDown(self):
rmtree(self.tmp)
def get(self, body, ext=".md", enc="utf-8"):
self.app.config.update(FLATPAGES_EXTENSION=ext)
with open(os.path.join(self.content, "test" + ext), "w", enc) as f:
f.write(u"title:test\n\n" + body)
return self.pages.get("test").html
def test_h1(self):
self.assertEqual(self.get("# test"), '<h1 id="test">test</h1>\n')
def test_unicode(self):
self.assertEqual(self.get(u"萬大事都有得解決"), u"<p>萬大事都有得解決</p>\n")
def test_unicode2(self):
self.app.config.update(FLATPAGES_ENCODING="iso-8859-15")
self.assertEqual(self.get(u"äöü", enc="iso-8859-15"), u"<p>äöü</p>\n")
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 create_app(config_name):
app = Flask(__name__)
app.config.from_pyfile('config.py')
global flatpages
flatpages = FlatPages(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
return app
def test_headerid_with_toc(self):
app = Flask(__name__)
pages = FlatPages(app)
pages.app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = [
'codehilite', 'toc' #headerid is deprecated in Markdown 3.0
]
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>'
)
self.check_default_codehilite_page(pages) #test codehilite also loaded
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(config):
def _initialize(app):
"""Load the external website settings and assets configurations into current application
:param app:
:return:
"""
if app.initialized:
return app
cwd = app.path
config_file = path.join(cwd, '_config.yml')
asset_file = path.join(cwd, "_assets.yml")
if path.exists(config_file):
settings = yaml.load(open(config_file).read())
app.site = Site(**settings)
app.config['BABEL_DEFAULT_LOCALE'] = getattr(
app.site, 'lang', 'en')
else:
raise IOError(
'System initialize fail: the `_config.yml` can not be found in the root of current website.'
)
path.exists(asset_file) and app.assets_env.register(
YAMLLoader(asset_file).load_bundles())
app.url_map.converters['regex'] = RegexConverter
app.initialized = True
return app
app = Flask(__name__, static_url_path='/static/vendors')
app.config.from_object(config)
Bootstrap(app)
babel = Babel(app)
app.pages = FlatPages(app)
app.assets_env = Environment(app)
app.path = config.APP_PATH
app.init = lambda: _initialize(app)
app.initialized = False
app.url_map.converters['regex'] = RegexConverter
@babel.localeselector
def get_local():
if hasattr(g, 'lang'):
_lang = getattr(g, 'lang', 'en')
else:
_lang = getattr(app.site, 'lang', 'en')
if _lang != '':
return _lang
else:
return 'en'
return app
class CategorizedFlatPages(object):
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(),
cmp=compare))
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 = []
for a in self.root_category.categories.get(category_id).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(object):
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(),
cmp=compare))
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 = []
for a in self.root_category.categories.get(
category_id).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 register_pages(app):
"""Initializes and register flat pages in g.pages"""
pages = FlatPages(app)
def before():
"""Before request event to attach g.pages"""
g.pages = PagesRepository(pages)
app.before_request(before)
class TestPages(TestCase):
def setUp(self):
app.config['FLATPAGES_ROOT'] = 'test/test_pages'
self.pages = FlatPages(app)
def test_get_fenced_blocks(self):
page = self.pages.get('test-install-python')
code = fenced_code(page.html)
assert_not_in('Verified on MacOSX', code)
assert_in('brew install python3', code)
class TestPages(TestCase):
def setUp(self):
app.config["FLATPAGES_ROOT"] = "test/test_pages"
self.pages = FlatPages(app)
def test_get_fenced_blocks(self):
page = self.pages.get("test-install-python")
code = fenced_code(page.html)
assert_not_in("Verified on MacOSX", code)
assert_in("brew install python3", code)
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_codehilite_linenums_enabled(self):
app = Flask(__name__)
app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = ['codehilite']
app.config['FLATPAGES_EXTENSION_CONFIGS'] = {
'codehilite': {
'linenums': 'True'
}
}
pages = FlatPages(app)
self.check_codehilite_with_linenums(pages)
def test_mixed_extension_types(self):
app = Flask(__name__)
from markdown.extensions.toc import TocExtension
toc = TocExtension()
app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = [
toc, 'codehilite', 'markdown.extensions.extra:ExtraExtension'
]
pages = FlatPages(app)
self.check_toc_page(pages)
self.check_default_codehilite_page(pages)
self.check_extra(pages)
app.config['FLATPAGES_EXTENSION_CONFIGS'] = {
'codehilite': {
'linenums': 'True'
}
}
pages.reload()
pages._file_cache = {}
self.check_toc_page(pages)
self.check_extra(pages)
self.check_codehilite_with_linenums(pages)
def setUp(self):
self.tmp = mkdtemp()
self.content = os.path.join(self.tmp, "content")
os.makedirs(self.content)
self.app = Flask(__name__)
self.app.config.update(
FLATPAGES_ROOT=self.content,
FLATPAGES_ENCODING="utf-8",
FLATPAGES_AUTO_RELOAD=True,
)
self.pages = FlatPages(self.app)
FlatPagesPandoc("markdown", self.app, pre_render=False)
def setUp(self):
self.tmp = mkdtemp()
self.content = os.path.join(self.tmp, "content")
os.makedirs(self.content)
self.app = Flask(__name__, static_folder=os.path.join(self.tmp, "static"))
self.app.config.update(
FLATPAGES_ROOT=self.content,
FLATPAGES_AUTO_RELOAD=True,
FLATPAGES_ENCODING="utf-8",
FLATPAGES_MARKDOWN_EXTENSIONS=["fenced_code"],
)
self.pages = FlatPages(self.app)
FlatPagesKnitr(self.app)
def test_mixed_extension_types(self):
app = Flask(__name__)
from markdown.extensions.toc import TocExtension
toc = TocExtension()
app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = [
toc,
'codehilite',
'markdown.extensions.extra:ExtraExtension'
]
pages = FlatPages(app)
self.check_toc_page(pages)
self.check_default_codehilite_page(pages)
self.check_extra(pages)
app.config['FLATPAGES_EXTENSION_CONFIGS'] = {
'codehilite': {
'linenums': 'True'
}
}
pages.reload()
pages._file_cache = {}
self.check_toc_page(pages)
self.check_extra(pages)
self.check_codehilite_with_linenums(pages)
def admin():
# Handle forwarding if redirected here after login
if session.get("next_url"):
next_url = session.get("next_url")
session.pop("next_url", None)
return redirect(next_url)
# Process form data
form = AdminForm()
form.tag.choices = app.config["BLOG_TAGS"]
if form.validate_on_submit():
pages_directory = (Path() / app.config["FLASK_APP"] /
app.config["FLATPAGES_ROOT"])
if not pages_directory.exists():
abort(500)
result = form.save(
template="page_contents.j2",
directory=pages_directory,
)
if result:
FlatPages.reload(pages)
flash("Blog entry posted successfully!", "Info")
else:
flash("Something went wrong. Please try again shortly.", "Error")
return redirect(url_for("admin"))
else:
if form.errors:
flash(
"Please correct errors detected in your form",
"Error",
)
return render_template("admin.j2", form=form)
def temp_pages(app=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__)
app.config['FLATPAGES_ROOT'] = temp
yield FlatPages(app)
def test_basic(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>')
self.check_default_codehilite_page(pages)
class TestFlatPagesKnitr(unittest.TestCase):
def setUp(self):
self.tmp = mkdtemp()
self.content = os.path.join(self.tmp, "content")
os.makedirs(self.content)
self.app = Flask(__name__, static_folder=os.path.join(self.tmp, "static"))
self.app.config.update(
FLATPAGES_ROOT=self.content,
FLATPAGES_AUTO_RELOAD=True,
FLATPAGES_ENCODING="utf-8",
FLATPAGES_MARKDOWN_EXTENSIONS=["fenced_code"],
)
self.pages = FlatPages(self.app)
FlatPagesKnitr(self.app)
def tearDown(self):
rmtree(self.tmp)
def get(self, body, ext=".Rmd", enc="utf-8"):
self.app.config.update(FLATPAGES_EXTENSION=ext)
with open(os.path.join(self.content, "test" + ext), "w", enc) as f:
f.write("title:test\n\n" + body)
return self.pages.get("test").html
def test_rmd(self):
self.assertEqual(self.get("#test"), "<h1>test</h1>")
def test_r(self):
self.assertTrue("3.14" in self.get("```{r}\npi\n```"))
def test_plot(self):
self.get("```{r, test}\nplot(1:4, 1:4)\n```")
self.assertTrue(os.path.exists(os.path.join(
self.tmp, "static", "knitr", "test", "figure", "test-1.png")))
def test_unicode(self):
self.assertTrue(u"萬大事都有得解決" in self.get(u"```{r}\npaste('萬大事都有得解決')\n```"))
def test_unicode2(self):
self.app.config.update(FLATPAGES_ENCODING="iso-8859-15")
self.assertEqual(self.get(u"äöü", enc="iso-8859-15"), u"<p>äöü</p>")
def __init__(self):
### make temporary directory to store frozen build
temp_dir = tempfile.mkdtemp()
app = Flask(__name__)
flatpages = FlatPages(app)
app.config['FLATPAGES_EXTENSION'] = '.md'
app.config['FLATPAGES_ROOT'] = 'cover-letters'
app.config['FREEZER_DESTINATION'] = temp_dir
freezer = Freezer(app)
### initialize the sqlite database
DB = database()
self.DB = DB
self.app = app
self.flatpages = flatpages
self.freezer = freezer
self.temp_dir = temp_dir
def create_app(config=config):
app = Flask(__name__)
app.config.update(
DEBUG=True,
FLATPAGES_AUTO_RELOAD=True,
FLATPAGES_EXTENSION=".md",
FLATPAGES_ROOT=config.POSTS_PATH,
FREEZER_RELATIVE_URLS=True,
FREEZER_DESTINATION=config.BUILD_PATH,
POSTS_PER_PAGE=config.POSTS_PER_PAGE,
MEDIA_PATH=config.MEDIA_PATH
)
app.register_blueprint(posts_bp)
raw_posts = FlatPages(app)
def load_pages():
all_posts = PageCollection(raw_posts)
all_posts.compute_embedded_media()
g.all_posts = all_posts
app.before_request(load_pages)
return app
def test_headerid_with_toc(self):
app = Flask(__name__)
pages = FlatPages(app)
pages.app.config['FLATPAGES_MARKDOWN_EXTENSIONS'] = [
'codehilite',
'toc' #headerid is deprecated in Markdown 3.0
]
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>')
self.check_default_codehilite_page(pages) #test codehilite also loaded
from flask import Flask from flask_flatpages import FlatPages, pygments_style_defs app = Flask(__name__) pages = FlatPages() APP_SETTINGS = "app.cfg" app.config.from_pyfile(APP_SETTINGS) pages.init_app(app) import blog.views
logging.basicConfig(level=logging.DEBUG)
# specific loggers
logging.getLogger('cubes').setLevel(logging.WARNING)
logging.getLogger('markdown').setLevel(logging.WARNING)
logging.getLogger('boto').setLevel(logging.WARNING)
logging.getLogger('spendb.core.cors').setLevel(logging.WARNING)
db = SQLAlchemy()
babel = Babel()
login_manager = LoginManager()
cache = Cache()
mail = Mail()
migrate = Migrate()
pages = FlatPages()
data_manager = DataManager()
cors = CORS()
def create_app(**config):
app = Flask(__name__)
app.config.from_object(default_settings)
app.config.from_envvar('SPENDB_SETTINGS', silent=True)
app.config.update(config)
db.init_app(app)
babel.init_app(app)
cache.init_app(app)
mail.init_app(app)
def setUp(self):
app.config["FLATPAGES_ROOT"] = "test/test_pages"
self.pages = FlatPages(app)
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 __init__(self):
self.flat_pages = FlatPages()
self.root_category = Category(None, '<root>')
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_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)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import unicode_literals # unicode by default
import datetime
from flask import render_template, redirect, url_for
from flask_flatpages import FlatPages
from .app import app
from .util import add_l10n_prefix, remove_l10n_prefix
from .blog import authors, sorted_authors, posts, sorted_posts, get_post_url, posts_by_tag, tags, categories, historias_posts, sorted_historias_posts, historia_get_post_url, historias_posts_by_tag, historias_tags, historias_categories
# Add the FlatPages extension
pages = FlatPages(app, 'pages')
@app.route('/<path:path>/')
def page(path):
''' All pages from markdown files '''
# Get the page
page = pages.get_or_404(add_l10n_prefix(path))
# Get custom template
template = page.meta.get('template', 'page.html')
# Verify if need redirect
redirect_ = page.meta.get('redirect', None)
if redirect_:
return redirect(url_for('page', path=redirect_))
def test_consistency(self):
pages = FlatPages(Flask(__name__))
for page in pages:
assert pages.get(page.path) is page
from flask import request, send_from_directory, render_template, render_template_string
from werkzeug.routing import BaseConverter
class RegexConverter(BaseConverter):
def __init__(self, url_map, *items):
super(RegexConverter, self).__init__(url_map)
self.regex = items[0]
app = Flask(__name__)
app.config.from_pyfile('config.py')
app.url_map.converters['regex'] = RegexConverter
from flask_flatpages import FlatPages
pages = FlatPages(app)
import misaka
import operator
import os
import houdini
import datetime
from pygments import highlight
from pygments.lexers import get_lexer_by_name
from pygments.formatters import HtmlFormatter
ROOT = os.path.dirname(os.path.realpath(__file__))
STATIC_URL = app.config['STATIC_URL']
POSTS_PER_PAGE = app.config['POSTS_PER_PAGE']
FLATPAGES_EXTENSION = app.config['FLATPAGES_EXTENSION']
# -*- coding: utf-8 -*-
'''mysite __init__
'''
from flask import Flask
from flask_flatpages import FlatPages
from flask_mail import Mail
app = Flask(__name__, instance_relative_config=True)
app.config.from_object('config')
app.config.from_pyfile('config.py')
Email = Mail(app)
app.config['FLATPAGES_EXTENSION'] = '.md'
flatpages = FlatPages()
flatpages.init_app(app)
# 注册蓝图
# 后import blog 是因为防止循环导入。
#blog中引用了flatpage, 如果放在前面则flatpage还未创建从而引发错误
from .blog import blog
#from .api import api
app.register_blueprint(blog)
#app.register_blueprint(api)
