.gitignore

@@ -121,4 +121,4 @@ dmypy.json
 
 # onpoint-specific
 test/slides.*.html
-**/.onpoint/
+

cache.py

@@ -1,77 +0,0 @@
-import os
-import time
-
-import helper
-
-timestamp_file_name = "last-compile.txt"
-
-# Check whether we are forced to recompile the entire project.
-# This is the case if:
-#   (a) the project was not compiled yet or
-#   (b) meta.yml was changed since the last compile or
-#   (c) the layouts have been changed since the last compile
-# The current time is saved to the cache folder for later use.
-def is_recompile_obligatory(root, lang):
-  if not os.path.isdir(os.path.join(root, ".onpoint", lang)):
-    # case (a)
-    __init_cache_directory(root, lang)
-    print("First compile, no caches available.")
-    save_compile_timestamp(root, lang)
-    return True
-  if file_touched_since_last_compile(root, lang, "meta.yml"):
-    # case (b)
-    print("meta.yml changed since the last compilation, forced to recompile.")
-    return True
-
-  for file in os.listdir(os.path.join(root, 'layouts')):
-    if os.path.isfile(os.path.join(root, 'layouts', file)):
-      layout_path = os.path.join('layouts', file)
-      if file_touched_since_last_compile(root, lang, layout_path):
-        # case (c)
-        print("Templates changed since the last compilation, forced to recompile.")
-        return True
-  return False
-
-# Check if some file was touched since the last compile.
-def file_touched_since_last_compile(root, lang, file):
-  file_path = os.path.join(root, file)
-  modification_time = helper.get_modification_time(file_path)
-  compilation_time = __get_last_compile_time(root, lang)
-  return modification_time > compilation_time
-
-# Check whether a cached version of this file exists.
-def not_cached_before(root, lang, file):
-  file_path = os.path.join(root, '.onpoint', lang, file + '.cache')
-  return not os.path.exists(file_path)
-
-# Restore the cached chapter.
-def get_cached_chapter(root, lang, chapter):
-  chapter_path = os.path.join(root, '.onpoint', lang, chapter + '.cache')
-  return open(chapter_path, 'r').read()
-
-# Store a cached version of a chapter.
-def store_cached_chapter(root, lang, chapter, content):
-  chapter_path = os.path.join(root, '.onpoint', lang, chapter + '.cache')
-  chapter_file = open(chapter_path, 'w')
-  chapter_file.write(content)
-  chapter_file.close()
-
-# Initialize the cache directory '.onpoint' in the project's root folder.
-# It will contain a file storing the last compile time and a directory
-# for each language. The latter will have cached versions of each chapter.
-def __init_cache_directory(root, lang):
-  cache_dir = os.path.join(root, '.onpoint', lang)
-  os.makedirs(cache_dir)
-
-# Save the current time to the timestamp file.
-def save_compile_timestamp(root, lang, file_name=timestamp_file_name):
-  timestamp_file_path = os.path.join(root, '.onpoint', lang, file_name)
-  timestamp_file = open(timestamp_file_path, 'w')
-  timestamp_file.write(str(int(time.time())))
-  timestamp_file.close()
-
-# Retrieve the compile timestamp.
-def __get_last_compile_time(root, lang):
-  timestamp_file_path = os.path.join(root, '.onpoint', lang, timestamp_file_name)
-  with open(timestamp_file_path) as f:
-    return int(f.readline())

chapters.py

@@ -1,6 +1,5 @@
 import os
 
-import cache
 import helper
 import slides as slides_helper
 
@@ -9,7 +8,7 @@ lang = ""
 
 # Compiles a presentation's chapters (the content without the wrapper)
 # according to slides.yml and returns them as one string of <section>s.
-def compile_chapters(root_directory, language, force_recompile=False):
+def compile_chapters(root_directory, language):
     global root
     root = root_directory
 
@@ -17,43 +16,23 @@ def compile_chapters(root_directory, language, force_recompile=False):
     lang = language
 
     structure = helper.read_yaml(root, 'slides.yml')
-    no_cache = cache.is_recompile_obligatory(root, lang) or force_recompile
-
     chapters = ""
     for chapter in structure:
-        chapters += '<section>\n' + compile_chapter(chapter, no_cache) + '\n</section>'
+        chapters += '<section>\n' + compile_chapter(chapter) + '\n</section>'
-
-    cache.save_compile_timestamp(root, lang)
     return chapters # string
 
 # Compiles a presentation's chapter (given its name) by splitting it into
 # slides, compiling those, and returning them as a string of <article>s.
-def compile_chapter(chapter, no_cache):
+def compile_chapter(chapter):
     global root
     if type(chapter) != str:
         raise Exception('Chapters with attributes are not supported yet.\n' +
                 str(chapter))
-
+    chapter_file = open(os.path.join(root, 'slides/' + chapter + '.' + lang + '.md'), 'r')
-    chapter_file_name = 'slides/' + chapter + '.' + lang + '.md'
-    chapter_path = os.path.join(root, chapter_file_name)
-
-    can_use_cache = not (
-        no_cache or
-        cache.not_cached_before(root, lang, chapter) or
-        cache.file_touched_since_last_compile(root, lang, chapter_file_name))
-
-    if can_use_cache:
-        print("Using cached version of chapter " + chapter + " (" + lang + ").")
-        return cache.get_cached_chapter(root, lang, chapter)
-
-    print("Recompiling chapter " + chapter + " (" + lang + ").")
-    chapter_file = open(chapter_path, 'r')
     delimiter = '\n@slide'
     chapter_input = ('\n' + chapter_file.read()).split(delimiter)
     slides = [delimiter + slide for slide in chapter_input][1:]
-    chapter_content = ''
+    chapter = ''
     for slide in slides:
-        chapter_content += '<article>\n' + slides_helper.compile_slide(slide, root) + '\n</article>\n'
+        chapter += '<article>\n' + slides_helper.compile_slide(slide, root) + '\n</article>\n'
-
+    return chapter
-    cache.store_cached_chapter(root, lang, chapter, chapter_content)
-    return chapter_content

helper.py

@@ -1,6 +1,5 @@
-import os
-import stat
 import yaml
+import os
 
 # Calls a YAML parser for the given relative path inside the presentation root
 # directory. Returns a dictionary with the YAML content.
@@ -25,8 +24,4 @@ def insert_metadata(content, root, lang):
         # print('replace', placeholder, 'with', filler)
         if '@' + key in content:
             content = content.replace(placeholder, filler)
-    return content
+    return content
-
-# Retrieve the modification time for a given file.
-def get_modification_time(path):
-    return os.stat(path)[stat.ST_MTIME]

main.py

@@ -10,10 +10,9 @@ import helper
 
 # Compiles a presentation in the given language from the given directory and
 # stores it in a corresponding slides.lang.html file inside the same directory.
-def compile(root, language='en', force_recompile=False):
+def compile(root, language='en'):
     wrapper = open(os.path.join(root, 'layouts/root.html'), 'r').read()
-    compiled_chapters = chapters.compile_chapters(root, language, force_recompile)
+    wrapper = wrapper.replace('@slides', chapters.compile_chapters(root, language))
-    wrapper = wrapper.replace('@slides', compiled_chapters)
     wrapper = helper.insert_metadata(wrapper, root, language)
     wrapper = fragments.defragmentize(wrapper)
     with open(os.path.join(root, 'slides.' + language + '.html'), 'w+') as output:
@@ -24,14 +23,12 @@ if __name__ == '__main__':
     parser = argparse.ArgumentParser()
     parser.add_argument("rootdirectory", help="your project's root directory")
     parser.add_argument("-l", "--language", default="all", help="the presentation language (default: all)")
-    parser.add_argument("-f", "--force-recompile", action='store_true', help="recompiling the entire presentation without caches")
 
     args = parser.parse_args()
-    force_recompile = False or args.force_recompile
 
     if args.language == "all":
         for language in helper.get_available_languages(args.rootdirectory):
-            compile(args.rootdirectory, language=language, force_recompile=force_recompile)
+            compile(args.rootdirectory, language=language)
     else:
-        compile(args.rootdirectory, language=args.language, force_recompile=force_recompile)
+        compile(args.rootdirectory, language=args.language)