1

from django.conf import settings

     2

     3

import codecs

     4

import logging; log = logging.getLogger('qmsk_www_pages.pages')

     5

import os, os.path

     6

     7

class Tree (object):

     8

    INDEX = 'index'

     9

    10

    @classmethod

    11

    def lookup (cls, parts):

    12

        path = settings.QMSK_WWW_PAGES_DIR

    13

    14

        for part in parts:

    15

            if part.startswith('.'):

    16

                # evil

    17

                return None

    18

    19

            if not part:

    20

                continue

    21

    22

            path = os.path.join(path, part)

    23

    24

            if not os.path.exists(path):

    25

                return None

    26

    27

            if not os.path.isdir(path):

    28

                return None

    29

    30

        return cls(path, parts)

    31

    32

    def __init__ (self, path, parts):

    33

        self.path = path

    34

        self.parts = parts

    35

    36

    37

    def url (self, tree=None, page=None):

    38

        path = '/'.join(self.parts)

    39

    40

        if path:

    41

            path += '/'

    42

    43

        if tree:

    44

            path = tree + '/'

    45

    46

        if page:

    47

            path += page

    48

    49

        return path

    50

    61

    def scan (self):

    62

        """

    63

            Scan for files in tree.

    64

        """

    65

    66

        for filename in os.listdir(self.path):

    67

            if filename.startswith('.'):

    68

                continue

    69

    70

            if '.' in filename:

    71

                file_name, file_type = filename.rsplit('.', 1)

    72

            else:

    73

                file_name = filename

    74

                file_type = None

    75

    76

            if not file_name:

    77

                continue

    78

    79

            path = os.path.join(self.path, filename)

    80

    81

            yield path, file_name, file_type

    82

    83

    def list (self):

    84

        """

    85

            Lists all Trees and Pages for this Tree

    86

        """

    87

    88

        for path, file_name, file_type in self.scan():

    89

            # trees

    90

            if os.path.isdir(path):

    91

                yield self.url(tree=file_name), file_name

    92

    93

            if file_name == self.INDEX:

    94

                continue

    95

    96

            # pages

    97

            if not file_type:

    98

                continue

    99

   100

            if file_type not in TYPES:

   101

                continue

   102

   103

            yield self.url(page=file_name), file_name

   104

   105

    def page (self, name):

   106

        """

   107

            Scans through tree looking for a matching page.

   108

   109

            Returns Page.

   110

        """

   111

   112

        if not name:

   113

            name = self.INDEX

   114

   115

        for path, file_name, file_type in self.scan():

   116

            # match on name

   117

            if file_name != name:

   118

                continue

   119

   120

            # match on type

   121

            if not file_type:

   122

                continue

   123

   124

            page_type = TYPES.get(file_type)

   125

   126

            if not page_type:

   127

                continue

   128

   129

            # out

   130

            return page_type(

   131

                path    = path,

   132

                name    = name,

   133

                tree    = self,

   134

            )

   135

   136

class Page (object):

   137

    ENCODING = 'utf-8'

   138

   139

    @classmethod

   140

    def lookup (cls, page):

   141

        """

   142

            Lookup a Page from disk.

   143

   144

            Returns None if there is no such page.

   145

        """

   146

   147

        log.info("page=%r", page)

   148

   149

        if page:

   150

            parts = page.split('/')

   151

        else:

   152

            parts = [ ]

   153

   154

        if parts:

   155

            page_name = parts.pop(-1)

   156

            tree_parts = parts

   157

        else:

   158

            page_name = ''

   159

            tree_parts = []

   160

   161

        # scan dir

   162

        tree = Tree.lookup(tree_parts)

   163

   164

        if not tree:

   165

            return None

   166

   167

        # scan page

   168

        page = tree.page(page_name)

   169

   170

        if not page:

   171

            return None

   172

   173

        return page

   174

   175

    def __init__ (self, path, name, tree, encoding=ENCODING):

   176

        self.path = path

   177

        self.name = name

   178

        self.tree = tree

   179

        self.encoding = encoding

   180

   184

    def open (self):

   185

        return codecs.open(self.path, encoding=self.encoding)

   186

   187

    def breadcrumb (self):

   190

   191

        if self.name != self.tree.INDEX:

   193

   194

    def render (self, request):

   195

        raise NotImplementedError()

   196

   197

class HTML_Page (Page):

   198

    def render (self, request):

   199

        return self.open().read()

   200

   201

TYPES = {

   202

    'html':         HTML_Page,

   203

}