Python FlatPages.reload方法代碼示例

# 需要導入模塊: from flask_flatpages import FlatPages [as 別名]
# 或者: from flask_flatpages.FlatPages import reload [as 別名]
    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>'
        )

# 需要導入模塊: from flask_flatpages import FlatPages [as 別名]
# 或者: from flask_flatpages.FlatPages import reload [as 別名]
 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)

# 需要導入模塊: from flask_flatpages import FlatPages [as 別名]
# 或者: from flask_flatpages.FlatPages import reload [as 別名]
 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)

# 需要導入模塊: from flask_flatpages import FlatPages [as 別名]
# 或者: from flask_flatpages.FlatPages import reload [as 別名]
 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)

# 需要導入模塊: from flask_flatpages import FlatPages [as 別名]
# 或者: from flask_flatpages.FlatPages import reload [as 別名]
    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_flatpages import FlatPages [as 別名]
# 或者: from flask_flatpages.FlatPages import reload [as 別名]
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()

# 需要導入模塊: from flask_flatpages import FlatPages [as 別名]
# 或者: from flask_flatpages.FlatPages import reload [as 別名]
 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)

# 需要導入模塊: from flask_flatpages import FlatPages [as 別名]
# 或者: from flask_flatpages.FlatPages import reload [as 別名]
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()