feat: use pathlib.Path for template paths

This commit modifies the django-pattern-library to use pathlib.Path for template paths. This ensures that the paths are handled consistently across different operating systems, including Windows.
The following functions have been modified to use pathlib.Path:
path_to_section()
section_for()
get_template_dirs()
get_pattern_config_str()
get_pattern_markdown()
Additionally, the TemplateRenderer.get_pattern_templates() method has been updated to use pathlib.Path for template paths.
possibly related issue: #116

pattern_library/utils.py

@@ -12,6 +12,8 @@
 
 import markdown
 import yaml
+import pathlib
+from pathlib import Path
 
 from pattern_library import (
     get_pattern_context_var_name,
@@ -22,17 +24,20 @@
 from pattern_library.exceptions import TemplateIsNotPattern
 
 
+
+from django.utils.html import escape
+
 def path_to_section():
     section_config = get_sections()
     sections = {}
     for section, paths in section_config:
         for path in paths:
-            sections[path] = section
+            sections[Path(path)] = section
     return sections
 
 
 def is_pattern(template_name):
-    if not template_name.endswith(get_pattern_template_suffix()):
+    if not str(template_name).endswith(get_pattern_template_suffix()):
         return False
 
     section, path = section_for(os.path.dirname(template_name))
@@ -51,7 +56,7 @@ def is_pattern_library_context(context):
 def section_for(template_folder):
     paths = path_to_section()
     for path in paths:
-        if template_folder.startswith(path):
+        if str(template_folder).startswith(str(path)):
             return paths[path], path
     return None, None
 
@@ -79,77 +84,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):
     replace_pattern = "{}$".format(get_pattern_template_suffix())
     context_path = re.sub(replace_pattern, "", template_name)
@@ -227,27 +161,157 @@ 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 TemplateRenderer
 
-    if context is None:
-        context = Context()
 
-    pattern_template = get_template(template_name)
+class TemplateRenderer:
+    @classmethod
+    def get_pattern_templates(cls):
+        templates = base_dict()
+        template_dirs = get_template_dirs()
 
-    for node in pattern_template.template.nodelist:
-        if isinstance(node, ExtendsNode):
-            parent_template_name = node.parent_name.resolve(context)
-            ancestors.append(parent_template_name)
-            get_template_ancestors(
-                parent_template_name, context=context, ancestors=ancestors
+        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(Path(base_path))
+
+                # It has no section, ignore it
+                if not section:
+                    continue
+
+                found_templates = []
+                for current_file in files:
+                    pattern_path = Path(root) / Path(current_file)
+                    pattern_path = Path(pattern_path.relative_to(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 = Path(template.origin.template_name).relative_to(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 = Path(root).relative_to(lookup_dir)
+                    sub_folders = Path(lookup_dir_relpath).relative_to(path)
+                    templates_to_store = templates
+                    for folder in [section, *str(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"]
             )
-            break
 
-    return ancestors
+        # 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
+
+    @classmethod
+    def get_pattern_source(cls, template):
+        return cls._get_engine(template).get_pattern_source(template)
+
+    @classmethod
+    def get_template_ancestors(cls, template_name, context=None):
+        template = get_template(template_name)
+        return cls._get_engine(template).get_template_ancestors(template_name, context=context)
+
+    @classmethod
+    def _get_engine(cls, template):
+        if "jinja" in str(type(template)).lower():
+            return JinjaTemplateRenderer
+        return DTLTemplateRenderer
+
+class DTLTemplateRenderer:
+    @staticmethod
+    def get_pattern_source(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()
+
+        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)
+                ancestors.append(parent_template_name)
+                cls.get_template_ancestors(
+                    parent_template_name, context=context, ancestors=ancestors
+                )
+                break
+
+        return ancestors
+
+
+class JinjaTemplateRenderer:
+    @staticmethod
+    def get_pattern_source(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)
+            cls.get_template_ancestors(parent_template_name, context=context, ancestors=ancestors)
+
+        return ancestors