First pass at renderers

Author: gone

pattern_library/utils.py

@@ -22,6 +22,9 @@
 from pattern_library.exceptions import TemplateIsNotPattern
 
 
+
+from django.utils.html import escape
+
 def path_to_section():
     section_config = get_sections()
     sections = {}
@@ -79,75 +82,6 @@ def get_template_dirs():
     return template_dirs
 
 
-def get_pattern_templates():
-    templates = base_dict()
-    template_dirs = get_template_dirs()
-
-    for lookup_dir in template_dirs:
-        for root, dirs, files in os.walk(lookup_dir, topdown=True):
-            # Ignore folders without files
-            if not files:
-                continue
-
-            base_path = os.path.relpath(root, lookup_dir)
-            section, path = section_for(base_path)
-
-            # It has no section, ignore it
-            if not section:
-                continue
-
-            found_templates = []
-            for current_file in files:
-                pattern_path = os.path.join(root, current_file)
-                pattern_path = os.path.relpath(pattern_path, lookup_dir)
-
-                if is_pattern(pattern_path):
-                    template = get_template(pattern_path)
-                    pattern_config = get_pattern_config(pattern_path)
-                    pattern_name = pattern_config.get("name")
-                    pattern_filename = os.path.relpath(
-                        template.origin.template_name,
-                        base_path,
-                    )
-                    if pattern_name:
-                        template.pattern_name = pattern_name
-                    else:
-                        template.pattern_name = pattern_filename
-
-                    template.pattern_filename = pattern_filename
-
-                    found_templates.append(template)
-
-            if found_templates:
-                lookup_dir_relpath = os.path.relpath(root, lookup_dir)
-                sub_folders = os.path.relpath(lookup_dir_relpath, path)
-                templates_to_store = templates
-                for folder in [section, *sub_folders.split(os.sep)]:
-                    try:
-                        templates_to_store = templates_to_store["template_groups"][
-                            folder
-                        ]
-                    except KeyError:
-                        templates_to_store["template_groups"][folder] = base_dict()
-                        templates_to_store = templates_to_store["template_groups"][
-                            folder
-                        ]
-
-                templates_to_store["templates_stored"].extend(found_templates)
-
-    # Order the templates alphabetically
-    for templates_objs in templates["template_groups"].values():
-        templates_objs["template_groups"] = order_dict(
-            templates_objs["template_groups"]
-        )
-
-    # Order the top level by the sections
-    section_order = [section for section, _ in get_sections()]
-    templates["template_groups"] = order_dict(
-        templates["template_groups"], key_sort=lambda key: section_order.index(key)
-    )
-
-    return templates
 
 
 def get_pattern_config_str(template_name):
@@ -227,27 +161,149 @@ def render_pattern(request, template_name, allow_non_patterns=False, config=None
     return render_to_string(template_name, request=request, context=context)
 
 
-def get_template_ancestors(template_name, context=None, ancestors=None):
-    """
-    Returns a list of template names, starting with provided name
-    and followed by the names of any templates that extends until
-    the most extended template is reached.
-    """
-    if ancestors is None:
-        ancestors = [template_name]
+def get_renderer():
+    return JinjaTemplateRenderer
+
+
+class TemplateRenderer:
+
+    @classmethod
+    def get_pattern_templates(cls,):
+        templates = base_dict()
+        template_dirs = get_template_dirs()
+
+        for lookup_dir in template_dirs:
+            for root, dirs, files in os.walk(lookup_dir, topdown=True):
+                # Ignore folders without files
+                if not files:
+                    continue
+
+                base_path = os.path.relpath(root, lookup_dir)
+                section, path = section_for(base_path)
+
+                # It has no section, ignore it
+                if not section:
+                    continue
+
+                found_templates = []
+                for current_file in files:
+                    pattern_path = os.path.join(root, current_file)
+                    pattern_path = os.path.relpath(pattern_path, lookup_dir)
+
+                    if is_pattern(pattern_path):
+                        template = get_template(pattern_path)
+                        pattern_config = get_pattern_config(pattern_path)
+                        pattern_name = pattern_config.get("name")
+                        pattern_filename = os.path.relpath(
+                            template.origin.template_name,
+                            base_path,
+                        )
+                        if pattern_name:
+                            template.pattern_name = pattern_name
+                        else:
+                            template.pattern_name = pattern_filename
+
+                        template.pattern_filename = pattern_filename
+
+                        found_templates.append(template)
+
+                if found_templates:
+                    lookup_dir_relpath = os.path.relpath(root, lookup_dir)
+                    sub_folders = os.path.relpath(lookup_dir_relpath, path)
+                    templates_to_store = templates
+                    for folder in [section, *sub_folders.split(os.sep)]:
+                        try:
+                            templates_to_store = templates_to_store["template_groups"][
+                                folder
+                            ]
+                        except KeyError:
+                            templates_to_store["template_groups"][folder] = base_dict()
+
+                            templates_to_store = templates_to_store["template_groups"][
+                                folder
+                            ]
+
+                    templates_to_store["templates_stored"].extend(found_templates)
+
+        # Order the templates alphabetically
+        for templates_objs in templates["template_groups"].values():
+            templates_objs["template_groups"] = order_dict(
+                templates_objs["template_groups"]
+            )
+
+        # Order the top level by the sections
+        section_order = [section for section, _ in get_sections()]
+        templates["template_groups"] = order_dict(
+            templates["template_groups"], key_sort=lambda key: section_order.index(key)
+        )
+
+        return templates
+
+class DTLTemplateRenderer(TemplateRenderer):
+    @classmethod
+    def get_pattern_source(cls, template):
+        return escape(template.template.source)
+
+    @classmethod
+    def get_template_ancestors(cls, template_name, context=None, ancestors=None):
+        """
+        Returns a list of template names, starting with provided name
+        and followed by the names of any templates that extends until
+        the most extended template is reached.
+        """
+        if ancestors is None:
+            ancestors = [template_name]
 
-    if context is None:
-        context = Context()
+        if context is None:
+            context = Context()
 
-    pattern_template = get_template(template_name)
+        pattern_template = get_template(template_name)
 
-    for node in pattern_template.template.nodelist:
-        if isinstance(node, ExtendsNode):
-            parent_template_name = node.parent_name.resolve(context)
+        for node in pattern_template.template.nodelist:
+            if isinstance(node, ExtendsNode):
+                parent_template_name = node.parent_name.resolve(context)
+                ancestors.append(parent_template_name)
+                cls.get_template_ancestors(
+                    parent_template_name, context=context, ancestors=ancestors
+                )
+                break
+
+        return ancestors
+
+
+
+class JinjaTemplateRenderer(TemplateRenderer):
+
+    @classmethod
+    def get_pattern_source(cls, template):
+        with open(template.template.filename) as f:
+            source =  escape(f.read())
+        return source
+
+
+    @classmethod
+    def get_template_ancestors(cls, template_name, context=None, ancestors=None):
+        """
+        Returns a list of template names, starting with provided name
+        and followed by the names of any templates that extends until
+        the most extended template is reached.
+        """
+        from jinja2.nodes import Extends
+
+        if ancestors is None:
+            ancestors = [template_name]
+
+        if context is None:
+            context = Context()
+
+        pattern_template = get_template(template_name)
+        #todo - make sure envrionment has context passed in
+        environment = pattern_template.template.environment
+        nodelist = environment.parse(pattern_template.name)
+        parent_template_name = nodelist.find(Extends)
+        if parent_template_name:
             ancestors.append(parent_template_name)
-            get_template_ancestors(
-                parent_template_name, context=context, ancestors=ancestors
-            )
-            break
+            cls.get_template_ancestors(parent_template_name, context=context, ancestors=ancestors)
 
-    return ancestors
+        return ancestors
+>>>>>>> 68fea3c (First pass at renderers)

pattern_library/views.py

@@ -15,11 +15,10 @@
     get_pattern_config_str,
     get_pattern_context,
     get_pattern_markdown,
-    get_pattern_templates,
     get_sections,
-    get_template_ancestors,
     is_pattern,
     render_pattern,
+    get_renderer,
 )
 
 
@@ -52,7 +51,8 @@ def get_first_template(self, templates):
 
     def get(self, request, pattern_template_name=None):
         # Get all pattern templates
-        templates = get_pattern_templates()
+        renderer = get_renderer()
+        templates = renderer.get_pattern_templates()
 
         if pattern_template_name is None:
             # Just display the first pattern if a specific one isn't requested
@@ -67,7 +67,7 @@ def get(self, request, pattern_template_name=None):
         context = self.get_context_data()
         context["pattern_templates"] = templates
         context["pattern_template_name"] = pattern_template_name
-        context["pattern_source"] = escape(template.template.source)
+        context["pattern_source"] = renderer.get_pattern_source(template)
         context["pattern_config"] = escape(
             get_pattern_config_str(pattern_template_name)
         )
@@ -83,7 +83,8 @@ class RenderPatternView(TemplateView):
 
     @method_decorator(xframe_options_sameorigin)
     def get(self, request, pattern_template_name=None):
-        pattern_template_ancestors = get_template_ancestors(
+        renderer = get_renderer()
+        pattern_template_ancestors = renderer.get_template_ancestors(
             pattern_template_name,
             context=get_pattern_context(self.kwargs["pattern_template_name"]),
         )