Feat/typings support

.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"

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()
 ```
 

blask/__init__.py

@@ -17,4 +17,4 @@
 along with this program. If not, see <http://www.gnu.org/licenses/>.
 """
 
-from blask.blaskapp import BlaskApp
+from blask.blask_app import BlaskApp

blask/blaskapp.py → 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(
-            "/<filename>", view_func=self._getpage, methods=["GET"])
-        self.app.add_url_rule(
-            "/<path:subpath>/<filename>",
+        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("/<filename>", view_func=self._getpage, methods=["GET"])
+        self.app.add_url_rule("/<path:subpath>/<filename>",
             view_func=self._get_subpage, methods=["GET"])
-        self.app.add_url_rule(
-            "/tag/<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/<category>",
-            view_func=self._getcategory, methods=["GET"])
-        self.app.add_url_rule(
-            "/author/<author>", view_func=self._getauthor, methods=["GET"])
+        self.app.add_url_rule("/tag/<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/<category>", view_func=self._getcategory, methods=["GET"])
+        self.app.add_url_rule("/author/<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,70 +111,75 @@ 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
         :return: Rendered tags search.
         """
         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
         :return:  rendered author search page
         """
         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)

blask/blaskcli.py → 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())

blask/blasksettings.py → 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}")