diff --git a/.env.example b/.env.example
index 51ae224..991c2bf 100644
--- a/.env.example
+++ b/.env.example
@@ -2,16 +2,16 @@
FLASK_APP=main.py
# Name of the Template Folder.
-templateDir="templates"
+template_dir="templates"
# Name of the post Folder
-postDir="posts"
+post_dir="posts"
# default name of the template file.
defaultLayout="template.html"
# Default name of the static Folder
-staticDir="static"
+static_dir="static"
# Title of the blog
title="Blask | A Simple Blog Engine Based on Flask"
diff --git a/README.md b/README.md
index dbf4513..3cf0cf6 100644
--- a/README.md
+++ b/README.md
@@ -23,10 +23,10 @@ git clone https://github.com/zerasul/blask.git
After downloading you need to create a `settings.py` file:
```python
-templateDir = "templates"
-postDir = "posts"
+template_dir = "templates"
+post_dir = "posts"
defaultLayout = "template.html"
-staticDir = "static"
+static_dir = "static"
title = "Blask | A Simple Blog Engine Based on Flask"
errors= { 404: "404"}
```
@@ -43,8 +43,8 @@ To Run Blask, use the following Code:
from blask import BlaskApp import settings
if __name__ == '__main__':
- b = BlaskApp(templateDir=settings.templateDir, postDir=settings.postDir, defaultLayout=settings.defaultLayout,
- staticDir=settings.staticDir, title=settings.title, errors={404:'404'})
+ b = BlaskApp(template_dir=settings.template_dir, post_dir=settings.post_dir, defaultLayout=settings.defaultLayout,
+ static_dir=settings.static_dir, title=settings.title, errors={404:'404'})
b.run()
```
diff --git a/blask/__init__.py b/blask/__init__.py
index 71fc1f7..d6b835c 100644
--- a/blask/__init__.py
+++ b/blask/__init__.py
@@ -17,4 +17,4 @@
along with this program. If not, see .
"""
-from blask.blaskapp import BlaskApp
+from blask.blask_app import BlaskApp
diff --git a/blask/blaskapp.py b/blask/blask_app.py
similarity index 74%
rename from blask/blaskapp.py
rename to blask/blask_app.py
index 8826822..de2f16f 100644
--- a/blask/blaskapp.py
+++ b/blask/blask_app.py
@@ -19,8 +19,8 @@
from werkzeug.utils import safe_join
from flask import Flask, render_template, request, abort, Response
from flask_wtf import CSRFProtect
-from blask.blasksettings import BlaskSettings
-from blask.blogrenderer import BlogRenderer
+from blask.blask_settings import BlaskSettings
+from blask.blog_renderer import BlogRenderer
from blask.errors import PageNotExistError
@@ -34,46 +34,38 @@ class BlaskApp:
app = None
blogrenderer = None
- def __init__(self, **kwargs):
+ def __init__(self, settings: dict = {}):
"""
- Initialices a new blask Instance
- :param kwargs: Dictionary with all the required settings;
- for more info see :settings
+ Initialices a new Blask instance
+
+ :param settings: Dictionary with all the required settings.
"""
- self.settings = BlaskSettings(**kwargs)
- self.blogrenderer = BlogRenderer(self.settings["postDir"])
+ self.settings: BlaskSettings = BlaskSettings(**settings)
+ self.blogrenderer: BlogRenderer = BlogRenderer(self.settings["post_dir"])
self.app = Flask(
__name__,
- template_folder=self.settings["templateDir"],
- static_folder=self.settings["staticDir"],
+ template_folder=self.settings["template_dir"],
+ static_folder=self.settings["static_dir"],
)
self.csrf = CSRFProtect()
self.csrf.init_app(self.app)
- self.app.add_url_rule(
- "/", endpoint="index", view_func=self._index, methods=["GET"])
- self.app.add_url_rule(
- "/sitemap.xml", view_func=self._get_sitemap, methods=["GET"])
- self.app.add_url_rule(
- "/", view_func=self._getpage, methods=["GET"])
- self.app.add_url_rule(
- "//",
+ self.app.add_url_rule("/", endpoint="index", view_func=self._index, methods=["GET"])
+ self.app.add_url_rule("/sitemap.xml", view_func=self._get_sitemap, methods=["GET"])
+ self.app.add_url_rule("/", view_func=self._getpage, methods=["GET"])
+ self.app.add_url_rule("//",
view_func=self._get_subpage, methods=["GET"])
- self.app.add_url_rule(
- "/tag/", view_func=self._gettag, methods=["GET"])
- self.app.add_url_rule(
- "/search", view_func=self.searchpages, methods=["POST"])
- self.app.add_url_rule(
- "/category/",
- view_func=self._getcategory, methods=["GET"])
- self.app.add_url_rule(
- "/author/", view_func=self._getauthor, methods=["GET"])
+ self.app.add_url_rule("/tag/", view_func=self._gettag, methods=["GET"])
+ self.app.add_url_rule("/search", view_func=self.searchpages, methods=["POST"])
+ self.app.add_url_rule("/category/", view_func=self._getcategory, methods=["GET"])
+ self.app.add_url_rule("/author/", view_func=self._getauthor, methods=["GET"])
+
# Register the error handler for each setting
for error in self.settings["errors"].keys():
self.app.register_error_handler(error, f=self._handle_http_errors)
- def _index(self):
+ def _index(self) -> str:
"""
Render the Index page
:return: rendered Index Page
@@ -82,10 +74,11 @@ def _index(self):
template = entry.template
if template is None:
template = self.settings["defaultLayout"]
+
return render_template(
template, title=self.settings["title"], content=entry.content)
- def _getpage(self, filename):
+ def _getpage(self, filename: str) -> str:
"""
Render a blog post
:param filename: Name of the Blog Post.
@@ -118,22 +111,23 @@ def _getpage(self, filename):
author=author,
)
- def _get_subpage(self, subpath, filename):
+ def _get_subpage(self, subpath: str, filename: str) -> str:
subfilename = safe_join(subpath, filename)
+
return self._getpage(subfilename)
- def _get_sitemap(self):
+ def _get_sitemap(self) -> Response:
"""
render the sitemap.xml file
:returns: prints the sitemapfile
"""
return Response(
self.blogrenderer.generate_sitemap_xml(
- self.settings["postDir"], request.url_root),
+ self.settings["post_dir"], request.url_root),
content_type="text/xml",
)
- def _gettag(self, tag):
+ def _gettag(self, tag: str) -> str:
"""
Render the Tags Page.
:param tag: Tag for search
@@ -141,40 +135,43 @@ def _gettag(self, tag):
"""
postlist = self.blogrenderer.list_posts([tag])
content = self.blogrenderer.generatetagpage(postlist)
+
return render_template(
self.settings["defaultLayout"],
title=self.settings["title"],
content=content
)
- def searchpages(self):
+ def searchpages(self) -> str:
"""
Render the search page. Must Be on Method POST
:return: rendered search Page
"""
postlist = self.blogrenderer.list_posts(search=request.form["search"])
content = self.blogrenderer.generatetagpage(postlist)
+
return render_template(
self.settings["defaultLayout"],
title=self.settings["title"],
content=content
)
- def _getcategory(self, category):
+ def _getcategory(self, category: str) -> str:
"""
Render a category searchpage
- :param category:
+ :param category: Category to list
:return: rendered category search page
"""
postlist = self.blogrenderer.list_posts(category=category)
content = self.blogrenderer.generatetagpage(postlist)
+
return render_template(
self.settings["defaultLayout"],
title=self.settings["title"],
content=content
)
- def _getauthor(self, author):
+ def _getauthor(self, author: str) -> str:
"""
Render an author searchpage
:param author: author parameter
@@ -182,6 +179,7 @@ def _getauthor(self, author):
"""
postlist = self.blogrenderer.list_posts(author=author)
content = self.blogrenderer.generatetagpage(postlist)
+
return render_template(
self.settings["defaultLayout"],
title=self.settings["title"],
@@ -197,9 +195,9 @@ def _handle_http_errors(self, error_message):
page = self.settings["errors"][error_message.code]
return self._getpage(page)
- def run(self, **kwargs):
+ def run(self, settings: dict):
"""
Run the current instance of blask
:param kwargs: Dictionary with all the required settings.
"""
- self.app.run(**kwargs)
+ self.app.run(**settings)
diff --git a/blask/blaskcli.py b/blask/blask_cli.py
similarity index 88%
rename from blask/blaskcli.py
rename to blask/blask_cli.py
index 53a2c5f..5768d46 100644
--- a/blask/blaskcli.py
+++ b/blask/blask_cli.py
@@ -23,7 +23,7 @@
import typer
-from blask import BlaskApp, blasksettings
+from blask import BlaskApp, blask_settings
LIB_DIR = Path(__file__).resolve().parents[0]
@@ -124,19 +124,19 @@ def init(
"""
typer.echo("Initializing new blask Project")
typer.echo("Using default Settings")
- postdir = path.basename(
- path.dirname(str(blasksettings.DEFAULT_SETTINGS["postDir"] + "/")))
- templatedir = path.basename(
- path.dirname(str(blasksettings.DEFAULT_SETTINGS["templateDir"] + "/"))
+ post_dir = path.basename(
+ path.dirname(str(blask_settings.DEFAULT_SETTINGS["post_dir"] + "/")))
+ template_dir = path.basename(
+ path.dirname(str(blask_settings.DEFAULT_SETTINGS["template_dir"] + "/"))
)
try:
- makedirs(postdir)
- cliController.createdefaultindexfile(path.join(postdir, "index.md"))
- makedirs(templatedir)
+ makedirs(post_dir)
+ cliController.createdefaultindexfile(path.join(post_dir, "index.md"))
+ makedirs(template_dir)
cliController.createdefaulttemplatefile(
- path.join(templatedir, "template.html"))
+ path.join(template_dir, "template.html"))
cliController.createsettingsfile()
- cliController.createnotfoundpage(path.join(postdir, '404.md'))
+ cliController.createnotfoundpage(path.join(post_dir, '404.md'))
if with_docker:
cliController.createdockerfile(path.join("Dockerfile"))
typer.echo("Created new blask project on %s" % getcwd())
diff --git a/blask/blasksettings.py b/blask/blask_settings.py
similarity index 76%
rename from blask/blasksettings.py
rename to blask/blask_settings.py
index 2d18c0f..d01facf 100644
--- a/blask/blasksettings.py
+++ b/blask/blask_settings.py
@@ -25,10 +25,10 @@
BASE_DIR = Path(".").resolve()
DEFAULT_SETTINGS = {
- "templateDir": str(BASE_DIR / "templates"),
- "postDir": str(BASE_DIR / "posts"),
- "defaultLayout": str("template.html"),
- "staticDir": str(BASE_DIR / "static"),
+ "template_dir": str(BASE_DIR / "templates"),
+ "post_dir": str(BASE_DIR / "posts"),
+ "default_layout": str("template.html"),
+ "static_dir": str(BASE_DIR / "static"),
"theme": None,
"title": "blask | A Simple Blog Engine Based on Flask",
"errors": {404: "404"} # Dictionary with errors handler
@@ -40,15 +40,13 @@ class BlaskSettings(): # pylint: disable=too-few-public-methods
blask configuration helper class
"""
- def __init__(self, **kwargs):
+ def __init__(self, settings: dict):
"""
- Initialize the blask Settings. First, look for the BLASK_SETTINGS
- environment variable and try to load the module.
- If BLASK_SETTINGS is not defined try to load the current
- settings from environment variables (defined in .env) and finally
- from the default values.
- Settings provided as arguments to the constructor always take
- precedence.
+ Initialize Blask settings module. First, look for the BLASK_SETTINGS environment variable
+ and try to load the module. If BLASK_SETTINGS is not defined try to load the current
+ settings from environment variables (defined in .env) and finally from the default values.
+ Settings provided as arguments to the constructor always take precedence.
+
:param args:
:param kwargs:
"""
@@ -61,7 +59,7 @@ def __init__(self, **kwargs):
settings_mod = import_module(
os.environ["BLASK_SETTINGS"], os.environ["BLASK_SETTINGS"])
# settings are stored in settings_mod.BASE_DIR,
- # settings_mod.templateDir, etc.
+ # settings_mod.template_dir, etc.
self.settings = {}
for key in DEFAULT_SETTINGS:
@@ -82,18 +80,19 @@ def __init__(self, **kwargs):
self.settings[key] = os.environ[key]
# arguments always override default and environment settings
- for kwarg in kwargs:
- if kwarg in DEFAULT_SETTINGS:
- self.settings[kwarg] = kwargs[kwarg]
+ for setting in settings:
+ if setting in DEFAULT_SETTINGS:
+ self.settings[setting] = settings[setting]
# Set theme
if self.settings["theme"] != None:
- self.settings["templateDir"] = str(BASE_DIR / "themes" / self.settings['theme'])
+ self.settings["template_dir"] = str(BASE_DIR / "themes" / self.settings['theme'])
- def __getitem__(self, key):
+ def __getitem__(self, key: str):
"""
Dictionary like settings access
"""
if key in self.settings:
return self.settings[key]
- raise KeyError("There is no blask setting called %s" % key)
+
+ raise KeyError(f"There is no setting named {key}")
diff --git a/blask/blog_entry.py b/blask/blog_entry.py
new file mode 100644
index 0000000..ec044f5
--- /dev/null
+++ b/blask/blog_entry.py
@@ -0,0 +1,71 @@
+from datetime import datetime
+
+DATE_FORMAT = "%Y-%m-%d"
+
+
+class BlogEntry:
+ """"
+ This class has the information about the Blog Posts.
+ Author: Zerasul
+ Version: 0.0.1.
+ """
+
+ content = None
+ """Content of the post."""
+ date = None
+ """Date of post creation"""
+ tags = []
+ """List of tags of the blog entry."""
+ author = None
+ """Author of the post"""
+ category = None
+ """Category of the post"""
+ template = None
+ """Name of the template file"""
+ name = None
+ """Name of the post"""
+ title = None
+ """Title of the Post"""
+ periodicity = None
+ """Periodicity of the post for sitemap"""
+
+ def __init__(self, name, md, content):
+ """
+ Default constructor
+ :param name: name of the post
+ :param md: Markdown information
+ :param content: String with the Content in HTML.
+ """
+ self.content = md.convert(content)
+ self.name = name
+ meta = md.Meta
+
+ if meta:
+ if "date" in meta.keys():
+ self.date = datetime.strptime(meta["date"][0], DATE_FORMAT)
+ if "tags" in meta.keys():
+ self.tags = meta["tags"][0].split(",")
+ if "template" in meta.keys():
+ self.template = meta["template"][0]
+ if "category" in meta.keys():
+ self.category = meta["category"][0]
+ if "author" in meta.keys():
+ self.author = meta["author"][0]
+ if "title" in meta.keys():
+ self.title = meta["title"][0]
+ if "periodicity" in meta.keys():
+ self.periodicity = meta["periodicity"][0]
+
+ def __str__(self):
+ """
+ Convert this object to String
+ :return: String with the data of this object.
+ """
+ string = (
+ f"['content': {self.content}, 'name': {self.name}, "
+ f"'date': {self.date}, 'tags':[{self.tags}], "
+ f"'author': {self.author}, 'category': {self.category}, "
+ f"'template': {self.template}]"
+ )
+
+ return string
diff --git a/blask/blogrenderer.py b/blask/blog_renderer.py
similarity index 67%
rename from blask/blogrenderer.py
rename to blask/blog_renderer.py
index 779b9a2..8cc811a 100644
--- a/blask/blogrenderer.py
+++ b/blask/blog_renderer.py
@@ -19,13 +19,15 @@
from os import path, listdir
from hashlib import sha3_512
from datetime import datetime
+
from xml.etree import ElementTree as ET
from werkzeug.utils import safe_join
from werkzeug.exceptions import NotFound
-
from markdown import Markdown
+from typing import List
from blask.errors import PageNotExistError
+from blask.blog_entry import BlogEntry
INDEX = "./index.md"
DATE_FORMAT = "%Y-%m-%d"
@@ -39,7 +41,7 @@ class BlogRenderer:
Version: 0.2.1
"""
- postdir = None
+ post_dir = None
"""
Posts Directory
"""
@@ -48,28 +50,27 @@ class BlogRenderer:
Post Cache; improves the post loading.
"""
- def __init__(self, postdir):
+ def __init__(self, post_dir: str):
"""
This is the constructor of the blog renderer.
- :param postdir: Posts Directory. See Settings py for more information.
+ :param post_dir: Posts Directory. See Settings py for more information.
"""
- self.postdir = postdir
+ self.post_dir = post_dir
- def renderfile(self, filename):
+ def renderfile(self, filename: str) -> BlogEntry:
"""
- Render a markdown and returns the blogEntry.
- Note: This method uses a cache based on a SHA-256 hash of the
- content.
+ Render a markdown and returns a BlogEntry.
+ Note: This method uses a cache based on a SHA-256 hash of the content.
:param filename: Name of the file without extension.
:return: BlogEntry.
:raises PageNotExistError Raise this error if file does not exist or
would fall out of the posts directory.
"""
page_not_exist_exception = PageNotExistError(
- f"{filename} does not exists in {self.postdir} directory")
+ f"{filename} does not exists in {self.post_dir} directory")
try:
file = f"{filename}.md"
- filepath = safe_join(self.postdir, file)
+ filepath = safe_join(self.post_dir, file)
except NotFound: # file would fall out of given directory
raise page_not_exist_exception
try:
@@ -86,7 +87,7 @@ def renderfile(self, filename):
return self.cache[content_hash]
# pylint: disable=R0201
- def rendertext(self, filename, text):
+ def rendertext(self, filename: str, text: str) -> BlogEntry:
"""
Render a Markdown Text and returns the BlogEntry.
:param filename: filename or title of the post.
@@ -96,18 +97,19 @@ def rendertext(self, filename, text):
mark_down = Markdown(
extensions=["meta", "markdown.extensions.codehilite"])
entry = BlogEntry(filename, mark_down, text)
+
return entry
# pylint: disable=dangerous-default-value
def list_posts(
self,
- tags=None,
- exclusions=[INDEX, "404.md"],
- search="",
- category="",
- author="",
- orderbydate=True,
- ):
+ tags: list = None,
+ exclusions: list = [INDEX, "404.md"],
+ search: str = "",
+ category: str = "",
+ author: str = "",
+ orderbydate: str = True,
+ ) -> List[BlogEntry]:
"""
Search a list of Posts returning a list of BlogEntry ordered By Date.
:param tags: list of tags for searching.
@@ -115,14 +117,14 @@ def list_posts(
:param search: string with the content what we want of search.
:param category: list of category of the entry.
:param author: name of the author of the post
- :param orderbydate: If is set to True the List is Date Inverse Ordered
- (Most new First).
+ :param orderbydate: If is set to True the List is Date Inverse Ordered (recent posts first).
:return: List of BlogEntry.
"""
+
files = list(
filter(
lambda l: l.endswith(".md") and l not in exclusions,
- self._listdirectoriesrecursive(self.postdir),
+ self._listdirectoriesrecursive(self.post_dir),
)
)
mapfilter = list(map(lambda l: path.splitext(l)[0], files))
@@ -138,15 +140,16 @@ def list_posts(
entries = list(filter(lambda l: search in l.content, entries))
if orderbydate:
# create a sublist with only entries with date
- dateredentries = list(filter(lambda e: e.date is None, entries))
- notdateredentries = list(
+ datered_entries = list(filter(lambda e: e.date is None, entries))
+ not_datered_entries = list(
filter(lambda d: d.date is not None, entries))
entries = list(
- sorted(dateredentries, key=lambda t: t.date is not None, reverse=True))
- entries.extend(notdateredentries)
+ sorted(datered_entries, key=lambda t: t.date is not None, reverse=True))
+ entries.extend(not_datered_entries)
+
return entries
- def _listdirectoriesrecursive(self, directory, append=""):
+ def _listdirectoriesrecursive(self, directory: str, append: str = "") -> List[str]:
"""
List the directory and subdirectories
:param directory: path of the directory where is searching.
@@ -161,11 +164,12 @@ def _listdirectoriesrecursive(self, directory, append=""):
)
else:
posts.append(safe_join(append, file))
+
return posts
- def generate_sitemap_xml(self, postlist, baseurl="http://localhost:5000"):
+ def generate_sitemap_xml(self, postlist: str, baseurl: str = "http://localhost:5000"):
"""
- Generate the Sitemap XML format output with all the posts in postdir
+ Generate the Sitemap XML format output with all the posts in post_dir
:param postlist: list with all the posts for the sitemapxml.
:return: return the xml output for the Sitemap.xml file.
"""
@@ -195,7 +199,7 @@ def generate_sitemap_xml(self, postlist, baseurl="http://localhost:5000"):
plocindex.text = baseurl + title
plastmodif = ET.SubElement(purlindex, "lastmod")
filetitle = f"{post.name}.md"
- tmp = path.getmtime(safe_join(self.postdir, filetitle))
+ tmp = path.getmtime(safe_join(self.post_dir, filetitle))
plastmodif.text = datetime.fromtimestamp(tmp).strftime(DATE_FORMAT)
pchangefreq = ET.SubElement(purlindex, "changefreq")
if post.periodicity:
@@ -207,84 +211,18 @@ def generate_sitemap_xml(self, postlist, baseurl="http://localhost:5000"):
return ET.tostring(root, encoding="UTF-8", method="xml")
# pylint: disable=R0201
- def generatetagpage(self, postlist):
+ def generatetagpage(self, post_list: list) -> str:
"""
Get a HTML with links of the entries.
:param postlist: List with BlogEntry.
:return: String with the HTML list.
"""
- content = ""
- for post in postlist:
+ content = ""
+
+ for post in post_list:
pname = post.name.replace("\\", "/").replace("./", "")
entrycontent = f"- {post.name}
"
content += entrycontent
- content += "
"
- return content
-
-
-# pylint: disable=too-few-public-methods
-class BlogEntry:
- """"
- This class has the information about the Blog Posts.
- Author: Zerasul
- Version: 0.0.1.
- """
- content = None
- """Content of the post."""
- date = None
- """ Date of post creation"""
- tags = []
- """List of tags of the blog entry."""
- author = None
- """Author of the post"""
- category = None
- """category of the post"""
- template = None
- """Name of the template file"""
- name = None
- """ Name of the post"""
- title = None
- """ Title of the Post"""
- periodicity = None
- """ periodicity of the post for sitemap"""
-
- def __init__(self, name, md, content):
- """
- Default constructor
- :param name: name of the post
- :param md: Markdown information
- :param content: String with the Content in HTML.
- """
- self.content = md.convert(content)
- self.name = name
- meta = md.Meta
- if meta:
- if "date" in meta.keys():
- self.date = datetime.strptime(meta["date"][0], DATE_FORMAT)
- if "tags" in meta.keys():
- self.tags = meta["tags"][0].split(",")
- if "template" in meta.keys():
- self.template = meta["template"][0]
- if "category" in meta.keys():
- self.category = meta["category"][0]
- if "author" in meta.keys():
- self.author = meta["author"][0]
- if "title" in meta.keys():
- self.title = meta["title"][0]
- if "periodicity" in meta.keys():
- self.periodicity = meta["periodicity"][0]
-
- def __str__(self):
- """
- Convert this object to String
- :return: String with the data of this object.
- """
- string = (
- f"['content': {self.content}, 'name': {self.name}, "
- f"'date': {self.date}, 'tags':[{self.tags}], "
- f"'author': {self.author}, 'category': {self.category}, "
- f"'template': {self.template}]"
- )
+ return f"{content}"
- return string
diff --git a/blask/default_env.env b/blask/default_env.env
index f5cbc38..4b94db4 100644
--- a/blask/default_env.env
+++ b/blask/default_env.env
@@ -2,16 +2,16 @@
FLASK_APP=main.py
# Name of the Template Folder.
-templateDir="templates"
+template_dir="templates"
# Name of the post Folder
-postDir="posts"
+post_dir="posts"
# default name of the template file.
defaultLayout='template.html'
# Default name of the static Folder
-staticDir='static'
+static_dir='static'
# Title of the blog
title='Blask | A Simple Blog Engine Based on Flask'
diff --git a/posts/docs.md b/posts/docs.md
index 9a8047f..7ae71c3 100644
--- a/posts/docs.md
+++ b/posts/docs.md
@@ -105,16 +105,16 @@ Here is an example:
BASE_DIR = os.getcwd()
# Templates directory
- templateDir = os.path.join(BASE_DIR, 'templates')
+ template_dir = os.path.join(BASE_DIR, 'templates')
# Posts directory
- postDir = os.path.join(BASE_DIR, 'posts')
+ post_dir = os.path.join(BASE_DIR, 'posts')
# Default layout template
defaultLayout = "template.html"
# Static files directory
- staticDir = os.path.join(BASE_DIR, 'static')
+ static_dir = os.path.join(BASE_DIR, 'static')
# Website title
title = 'Blask | A Simple Blog Engine Based on Flask'
@@ -128,10 +128,10 @@ Here is an example:
Here is the description of each configuration:
* **BASE_DIR**: Where is the working directory.
-* **templateDir**: Templates Folder. All the HTML for the templates must be there.
-* **postDir**: Posts Dir. All the markdown blog posts must be there.
-* **defaultLayout**: Default template file. This file must be in the _templateDir_ folder.
-* **staticDir**: Static resources folder. All the _css_, _js_, _img_ must be here.
+* **template_dir**: Templates Folder. All the HTML for the templates must be there.
+* **post_dir**: Posts Dir. All the markdown blog posts must be there.
+* **defaultLayout**: Default template file. This file must be in the _template_dir_ folder.
+* **static_dir**: Static resources folder. All the _css_, _js_, _img_ must be here.
* **title**: Default title for the site.
* **errors**: To set up custom errors for HTTP error codes.
@@ -147,9 +147,9 @@ where ```settings``` have the configuration module of Blask.
If you want to use the default values; you can see them here:
* **TemplatesDir**: _templates_.
-* **postDir**: _posts_.
+* **post_dir**: _posts_.
* **defaultLayout**: _template.html_.
-* **staticDir**: _static_
+* **static_dir**: _static_
* **tittle**: _Blask | A Simple Blog Engine Based on Flask_
## Create a Post
diff --git a/posts/examples.md b/posts/examples.md
index 49d1dfe..97fe657 100644
--- a/posts/examples.md
+++ b/posts/examples.md
@@ -12,16 +12,16 @@ First if you need to run Blask, need to see the `settings.py` file and set the p
BASE_DIR = os.getcwd()
# Templates directory
- templateDir = os.path.join(BASE_DIR, 'templates')
+ template_dir = os.path.join(BASE_DIR, 'templates')
# Posts directory
- postDir = os.path.join(BASE_DIR, 'posts')
+ post_dir = os.path.join(BASE_DIR, 'posts')
# Default layout template
defaultLayout = "template.html"
# Static files directory
- staticDir = os.path.join(BASE_DIR, 'static')
+ static_dir = os.path.join(BASE_DIR, 'static')
# Website title
title = 'Blask | A Simple Blog Engine Based on Flask'
diff --git a/posts/install.md b/posts/install.md
index 862392c..22afaf6 100644
--- a/posts/install.md
+++ b/posts/install.md
@@ -23,10 +23,10 @@ After that, you need to configure Blask, create a file called _settings.py_ file
from os import path
BASE_DIR = Path('.').resolve()
- templateDir = path.join(BASE_DIR, "templates")
- postDir = path.join(BASE_DIR, "posts")
+ template_dir = path.join(BASE_DIR, "templates")
+ post_dir = path.join(BASE_DIR, "posts")
defaultLayout = "template.html"
- staticDir = path.join(BASE_DIR, "static")
+ static_dir = path.join(BASE_DIR, "static")
title = "Blask"
errors = { 404:"404"}
@@ -42,8 +42,8 @@ You can run the application using this code:
import settings
if __name__ == '__main__':
- b = BlaskApp(templateDir=settings.templateDir, postDir=settings.postDir
- , defaultLayout=settings.defaultLayout, staticDir=settings.staticDir, title=settings.title, errors={404 : "404"})
+ b = BlaskApp(template_dir=settings.template_dir, post_dir=settings.post_dir
+ , defaultLayout=settings.defaultLayout, static_dir=settings.static_dir, title=settings.title, errors={404 : "404"})
b.run()
If you use the environment Variable you can run Blask without arguments:
diff --git a/settings.py b/settings.py
index 10c3cdd..71f7b1a 100644
--- a/settings.py
+++ b/settings.py
@@ -3,10 +3,10 @@
BASE_DIR = Path('.').resolve()
-templateDir = path.join(BASE_DIR, "templates")
-postDir = path.join(BASE_DIR, "posts")
+template_dir = path.join(BASE_DIR, "templates")
+post_dir = path.join(BASE_DIR, "posts")
defaultLayout = "template.html"
-staticDir = path.join(BASE_DIR, "static")
+static_dir = path.join(BASE_DIR, "static")
theme = "theme_example"
title = "blask | A Simple Blog Engine Based on Flask"
errors = {404: "404"}
diff --git a/tests/blogrender_test.py b/tests/blogrender_test.py
index 80ca1be..73e8f29 100644
--- a/tests/blogrender_test.py
+++ b/tests/blogrender_test.py
@@ -1,5 +1,5 @@
-from blask.blogrenderer import BlogRenderer
-from settings import postDir
+from blask.blog_renderer import BlogRenderer
+from settings import post_dir
from pytest import fixture, raises
from datetime import datetime
from blask.errors import PageNotExistError
@@ -13,7 +13,7 @@ class TestblogRender:
@fixture(autouse=True)
def initialize(self):
- self.blogrender = BlogRenderer(postDir)
+ self.blogrender = BlogRenderer(post_dir)
def test_rendering(self):
entry = self.blogrender.renderfile("index")
@@ -65,5 +65,5 @@ def test_list_directories(self):
assert "href='/releases/sub2/test" in entrieslist
def test_generate_sitemap_xml(self):
- mysxml = self.blogrender.generate_sitemap_xml(postDir)
+ mysxml = self.blogrender.generate_sitemap_xml(post_dir)
assert b"http://localhost:5000" in mysxml
diff --git a/tests/main_test.py b/tests/main_test.py
index 8fc36bc..99289f7 100644
--- a/tests/main_test.py
+++ b/tests/main_test.py
@@ -13,10 +13,10 @@ class TestMain:
@fixture(autouse=True)
def inittest(self):
b = BlaskApp(
- templateDir=settings.templateDir,
- postDir=settings.postDir,
+ template_dir=settings.template_dir,
+ post_dir=settings.post_dir,
defaultLayout=settings.defaultLayout,
- staticDir=settings.staticDir,
+ static_dir=settings.static_dir,
title=settings.title,
)
b.app.testing = True
diff --git a/tests/settings.py b/tests/settings.py
index 209831e..2de9fc1 100644
--- a/tests/settings.py
+++ b/tests/settings.py
@@ -4,16 +4,16 @@
BASE_DIR = Path(".").resolve()
# Templates directory
-templateDir = os.path.join(BASE_DIR, 'templates')
+template_dir = os.path.join(BASE_DIR, 'templates')
# Posts directory
-postDir = os.path.join(BASE_DIR, 'posts')
+post_dir = os.path.join(BASE_DIR, 'posts')
# Default layout template
defaultLayout = "template.html"
# Static files directory
-staticDir = os.path.join(BASE_DIR, 'static')
+static_dir = os.path.join(BASE_DIR, 'static')
# Website title
title = 'The mantis revenge!'
diff --git a/tests/settings_test.py b/tests/settings_test.py
index 11dd27a..ff5b0e4 100644
--- a/tests/settings_test.py
+++ b/tests/settings_test.py
@@ -4,8 +4,8 @@
import pytest
from dotenv import load_dotenv
-from blask import blasksettings
-from blask.blasksettings import BlaskSettings
+from blask import blask_settings
+from blask.blask_settings import BlaskSettings
class TestBlaskSettings:
@@ -14,14 +14,14 @@ def test_defaults(self):
# remove all environment variables
removed_vars = {}
- for key in blasksettings.DEFAULT_SETTINGS:
+ for key in blask_settings.DEFAULT_SETTINGS:
if key in os.environ:
value = os.environ.pop(key)
removed_vars[key] = value
settings = BlaskSettings()
- for kw in blasksettings.DEFAULT_SETTINGS.keys():
- assert settings[kw] == blasksettings.DEFAULT_SETTINGS[kw]
+ for kw in blask_settings.DEFAULT_SETTINGS.keys():
+ assert settings[kw] == blask_settings.DEFAULT_SETTINGS[kw]
# put environment variables back
for key, value in removed_vars.items():
@@ -31,7 +31,7 @@ def test_from_environ(self):
# remove all environment variables
removed_vars = {}
- for key in blasksettings.DEFAULT_SETTINGS:
+ for key in blask_settings.DEFAULT_SETTINGS:
if key in os.environ:
value = os.environ.pop(key)
removed_vars[key] = value
@@ -40,13 +40,13 @@ def test_from_environ(self):
os.environ['BLASK_SETTINGS'] = 'tests.testsettings'
settings = BlaskSettings()
- for kw in blasksettings.DEFAULT_SETTINGS.keys():
- if kw == 'postDir':
+ for kw in blask_settings.DEFAULT_SETTINGS.keys():
+ if kw == 'post_dir':
assert settings[kw] == str(Path('.').resolve() / 'posts2')
elif kw == 'title':
assert settings[kw] == 'The mantis revenge!'
else:
- assert settings[kw] == blasksettings.DEFAULT_SETTINGS[kw]
+ assert settings[kw] == blask_settings.DEFAULT_SETTINGS[kw]
del(os.environ['BLASK_SETTINGS'])
# put environment variables back
@@ -57,7 +57,7 @@ def test_from_environ(self):
def test_from_dotenv(self):
# remove all environment variables
removed_vars = {}
- for key in blasksettings.DEFAULT_SETTINGS:
+ for key in blask_settings.DEFAULT_SETTINGS:
if key in os.environ:
value = os.environ.pop(key)
removed_vars[key] = value
@@ -67,16 +67,16 @@ def test_from_dotenv(self):
# changed for new pytest
settings = BlaskSettings()
- for kw in blasksettings.DEFAULT_SETTINGS.keys():
- if kw == 'postDir':
+ for kw in blask_settings.DEFAULT_SETTINGS.keys():
+ if kw == 'post_dir':
assert settings[kw] == 'posts-env'
elif kw == 'title':
assert settings[kw] == "The mantis with dotenv?!"
else:
- assert settings[kw] == blasksettings.DEFAULT_SETTINGS[kw]
+ assert settings[kw] == blask_settings.DEFAULT_SETTINGS[kw]
# remove all test environment variables
- for key in blasksettings.DEFAULT_SETTINGS:
+ for key in blask_settings.DEFAULT_SETTINGS:
if key in os.environ:
os.environ.pop(key)
@@ -88,23 +88,23 @@ def test_kwargs(self):
# remove all environment variables
removed_vars = {}
- for key in blasksettings.DEFAULT_SETTINGS:
+ for key in blask_settings.DEFAULT_SETTINGS:
if key in os.environ:
value = os.environ.pop(key)
removed_vars[key] = value
kwsettings = {
- 'postDir': str(Path.cwd() / 'mantispostdir'),
+ 'post_dir': str(Path.cwd() / 'mantispost_dir'),
'title': 'The mantis has you!',
}
settings = BlaskSettings(**kwsettings)
- for kw in blasksettings.DEFAULT_SETTINGS.keys():
- if kw == 'postDir':
- assert settings[kw] == str(Path.cwd() / 'mantispostdir')
+ for kw in blask_settings.DEFAULT_SETTINGS.keys():
+ if kw == 'post_dir':
+ assert settings[kw] == str(Path.cwd() / 'mantispost_dir')
elif kw == 'title':
assert settings[kw] == 'The mantis has you!'
else:
- assert settings[kw] == blasksettings.DEFAULT_SETTINGS[kw]
+ assert settings[kw] == blask_settings.DEFAULT_SETTINGS[kw]
# put original environment variables back
for key, value in removed_vars.items():
diff --git a/tests/testsettings.py b/tests/testsettings.py
index b0c738d..4e4bace 100644
--- a/tests/testsettings.py
+++ b/tests/testsettings.py
@@ -4,16 +4,16 @@
BASE_DIR = Path(".").resolve()
# Templates directory
-templateDir = os.path.join(BASE_DIR, 'templates')
+template_dir = os.path.join(BASE_DIR, 'templates')
# Posts directory
-postDir = os.path.join(BASE_DIR, 'posts2')
+post_dir = os.path.join(BASE_DIR, 'posts2')
# Default layout template
defaultLayout = "template.html"
# Static files directory
-staticDir = os.path.join(BASE_DIR, 'static')
+static_dir = os.path.join(BASE_DIR, 'static')
# Website title
title = 'The mantis revenge!'