Let Zola do the SSG (#25)

* Large codeblocks restructure

* Remove unnecessary requirements

* Break Pylint3.x!

* More codeblocks

* Add error_handling page

* Update README.md

Author: Raymi306

Makefile

@@ -1,31 +1,12 @@
 .PHONY: default
-default: build
+default: clean lint
+	python3 -m app
 
 .PHONY: clean
 clean:
 	rm -rf dist
 .PHONY: lint
 lint:
 	pylint app
-.PHONY: init_dist_dir
-init_dist_dir:
-	mkdir -p dist
-.PHONY: basic_build
-basic_build: clean init_dist_dir
-	python -m app
-.PHONY: basic_build_new_internal_links
-basic_build_warn_links: clean init_dist_dir
-	python -m app --warn-links
-.PHONY: pygmentize_css
-pygmentize_css:
-	pygmentize -S solarized-light -f html -a .codehilite > dist/styles.css
-.PHONY: zip
-zip:
-	gzip -k -9 dist/*
-.PHONY: build
-build: lint basic_build pygmentize_css zip
-.PHONY: build_warn_links
-build_warn_links: lint basic_build_warn_links pygmentize_css zip
-.PHONY: rsync
 rsync:
-	rsync -rvz --progress -e 'ssh -p 57018' ./dist/* [email protected]:/srv/www/lt/andrew/tutorials/python
+	echo "rsync -rvz --progress -e 'ssh -p 57018' ./dist/* [email protected]:/srv/www/lt/andrew/tutorials/python"

README.md

@@ -1,14 +1,9 @@
 # python-tutorial
 
 ## Brief summary
-A tutorial with eventual content for both absolute beginners and experienced programmers.
-
-## Libraries
-[Python-Markdown](https://python-markdown.github.io/) - Converts Markdown to HTML
 
-[Jinja](https://jinja.palletsprojects.com/en/3.0.x/) - Templating, used for links, codeblocks, and HTML
-
-## Usage
-After cloning the repository, create a virtual environment `python3 -m venv venv` and install all dependencies in requirements.txt `pip install -r requirements.txt`.
+A tutorial with eventual content for both absolute beginners and experienced programmers.
+Codeblocks that are automatically tested before being exported for use on my personal page's Python tutorial.
 
-Refer to the Makefile for actions to take
+Once, this repository held both a site generator and the markdown content of my Python tutorial.
+It is due for a name change...

app/__init__.py

@@ -1,10 +1,3 @@
 """
-Package builds and performs QA of a python tutorial website
-Module provides config dictionary to other modules
+Package for providing tested codeblock data for templating in another program
 """
-__HOMEPAGE_URL = 'https://andrew.let-them.cyou'
-config = {
-        'DIST_PATH': 'dist',
-        'HOMEPAGE_URL': __HOMEPAGE_URL,
-        'TUTORIAL_BASE_URL': f'{__HOMEPAGE_URL}/tutorials/python',
-        }

app/__main__.py

@@ -1,44 +1,28 @@
-"""Module for building and build-time QA of the python tutorial website"""
-import argparse
+"""Module for building and build-time QA of the python tutorial codeblocks"""
+import inspect
+import json
 from os import makedirs
-from pathlib import Path
 import sys
 
-from jinja2 import Environment, PackageLoader, DebugUndefined
-from markdown import markdown
-from markdown.extensions.toc import TocExtension
-from markdown.extensions.codehilite import CodeHiliteExtension
+from app.codeblocks import get_func_body
+from app.pages import first_steps, first_projects, variables, classes, error_handling
+from app.qa import CodeblocksTester, BuildTestFailure
 
-from app import config
-from app.templates import TEMPLATES, BASE_HTML
-from app.templates.codeblocks import codeblocks
-from app.templates.links import links
-from app.qa import (
-    LinkTester, CodeblocksTester, UnresolvedTemplateVariablesTester, BuildTestFailure
-)
 
-parser = argparse.ArgumentParser()
-parser.add_argument(
-    '--dry-run',
-    action="store_true",
-    help="""
-    Do not write any files or directories.
-    Still perform network requests for link checks
-    """
-)
-parser.add_argument(
-    '--warn-links',
-    action="store_true",
-    help="Do not error on link checker failures",
+PAGE_MODULES = (
+     first_steps,
+     first_projects,
+     variables,
+     classes,
+     error_handling,
 )
 
-def run_build_checks(env, ctx, args):
+OUTPUT_DIR = "dist"
+
+
+def run_build_checks():
     """QA for build process"""
-    testers = (
-            LinkTester(warn=args.warn_links),
-            CodeblocksTester(),
-            UnresolvedTemplateVariablesTester(env, ctx),
-            )
+    testers = (CodeblocksTester(PAGE_MODULES),)
     fail = False
     for tester in testers:
         try:
@@ -49,53 +33,25 @@ def run_build_checks(env, ctx, args):
         sys.exit(1)
 
 
-def render_templates(env, ctx):
-    """
-    Generator
-    Render templates in correct order to produce a final render
-    """
-    py_md_extensions = (
-            'attr_list',
-            'fenced_code',
-            CodeHiliteExtension(guess_lang=False),
-            TocExtension(toc_depth='2-6', anchorlink=True),
-            )
-    base_html_template = env.get_template(BASE_HTML)
-
-    for name in TEMPLATES:
-        template = env.get_template(name)
-        html = markdown(
-                template.render(ctx),
-                extensions=py_md_extensions
-                )
-        final_render = base_html_template.render({'body_content': html})
-        path = Path(config['DIST_PATH'], Path(name).stem).with_suffix('.html')
-        yield final_render, path
-
-
-def write_render(render, path):
-    """Write final render to appropriate path"""
-    with open(path, 'w', encoding='utf-8') as f:
-        f.write(render)
-
-
-def main(args):
+def main():
     """
-    Perform all of the actions necessary to output the python tutorial webpages
+    Perform all of the actions necessary to output the python tutorial codeblocks
     """
-    env = Environment(
-            loader=PackageLoader('app'),
-            autoescape=False,
-            undefined=DebugUndefined,
-            )
-    ctx = {**codeblocks, **links}
-    run_build_checks(env, ctx, args)
-    if not args.dry_run:
-        makedirs('dist', exist_ok=True)
-        for render, path in render_templates(env, ctx):
-            write_render(render, path)
+    print()
+    run_build_checks()
+    print()
+    makedirs(OUTPUT_DIR, exist_ok=True)
+    with open(f'{OUTPUT_DIR}/codeblocks.json', 'w', encoding='utf-8') as f:
+        codeblock_map = {}
+        for module in PAGE_MODULES:
+            nonlocals = getattr(module, "NONLOCALS", ())
+            print(f"extracting from {module.__name__}:")
+            for member_name, member in inspect.getmembers(module, inspect.isfunction):
+                if member_name not in nonlocals:
+                    print("    ", member_name)
+                    codeblock_map[member_name] = get_func_body(member)
+        json.dump(codeblock_map, f)
 
 
 if __name__ == '__main__':
-    args_ = parser.parse_args()
-    main(args_)
+    main()

app/codeblocks.py

@@ -0,0 +1,66 @@
+"""
+Exports doctested, minimal codeblocks for templating
+Docstrings MUST be double quotes!
+"""
+
+import inspect
+
+
+def normalize_indentation(line, set_level, level):
+    """Remove unnecessary indentation resulting from doctesting of code"""
+    if line == '\n':
+        return line, level
+    counter = 0
+    length = len(line)
+    while counter < length - 1 and line[counter] == ' ':
+        counter += 1
+    if set_level:
+        level = int(counter / 4)
+        result = line[4 * level:], level
+    else:
+        index = 4 * level
+        result = line[index:], level
+    return ''.join(result[0]) + '\n', result[1]
+
+
+def get_func_body(name):
+    """
+    Remove docstrings, indentation, and testing artifacts from function
+    indicated by name for use with templating as a codeblock
+
+    Functions can be marked with # START and # END comments for special
+    trimming of testing code
+    """
+    raw = inspect.getsource(name)
+    lines = raw.split('\n')[1:]
+    set_level = True
+    level = None
+    consume_whitespace = True
+    result = []
+    if '# START' in raw and '# END' in raw:
+        take = False
+        for line in lines:
+            if '# END' in line:
+                take = False
+            if take:
+                if not line.strip() and consume_whitespace: # DRY :\
+                    continue
+                consume_whitespace = False
+                line, level = normalize_indentation(line, set_level, level)
+                set_level = False
+                result.append(line)
+            if '# START' in line:
+                take = True
+        return ''.join(result).strip() # confused myself with early return lol
+    docstring_occurences = 0
+    for line in lines:
+        if docstring_occurences >= 2:
+            if not line.strip() and consume_whitespace: # DRY :\
+                continue
+            consume_whitespace = False
+            line, level = normalize_indentation(line, set_level, level)
+            set_level = False
+            result.append(line)
+        docstring_occurences += line.count('"""')
+
+    return ''.join(result).strip()