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"]),
  )