1

from django.conf import settings

     2

     3

import codecs

     4

import datetime

     5

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

     6

import os, os.path

     7

     8

class Site (object):

     9

    @classmethod

    10

    def lookup (cls):

    11

        return cls(

    12

            root        = settings.QMSK_WWW_PAGES_DIR,

    13

            name        = settings.QMSK_WWW_PAGES_SITE,

    14

        )

    15

    16

    def __init__ (self, root, name):

    17

        self.root = root

    18

        self.name = name

    19

    20

class Tree (object):

    21

    INDEX = 'index'

    22

    23

    @classmethod

    24

    def lookup (cls, site, parts):

    25

        path = site.root

    26

    27

        for part in parts:

    28

            if part.startswith('.'):

    29

                # evil

    30

                return None

    31

    32

            if not part:

    33

                continue

    34

    35

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

    36

    37

            if not os.path.exists(path):

    38

                return None

    39

    40

            if not os.path.isdir(path):

    41

                return None

    42

    43

        return cls(path, parts, site)

    44

    45

    def __init__ (self, path, parts, site):

    46

        self.path = path

    47

        self.parts = parts

    48

        self.site = site

    49

    50

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

    51

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

    52

    53

        if path:

    54

            path += '/'

    55

    56

        if tree:

    57

            path = tree + '/'

    58

    59

        if page:

    60

            path += page

    61

    62

        return path

    63

    64

    def breadcrumb (self):

    65

        path = []

    66

    67

        yield '', self.site.name

    68

    69

        for part in self.parts:

    70

            path.append(part)

    71

    72

            yield '/'.join(path) + '/', part

    73

    74

    def scan (self):

    75

        """

    76

            Scan for files in tree.

    77

        """

    78

    79

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

    80

            if filename.startswith('.'):

    81

                continue

    82

    83

            if '.' in filename:

    84

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

    85

            else:

    86

                file_name = filename

    87

                file_type = None

    88

    89

            if not file_name:

    90

                continue

    91

    92

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

    93

    94

            yield path, file_name, file_type

    95

    96

    def list (self):

    97

        """

    98

            Lists all Trees and Pages for this Tree

    99

        """

   100

   101

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

   102

            # trees

   103

            if os.path.isdir(path):

   104

                yield self.url(tree=file_name), file_name, None

   105

   106

            if file_name == self.INDEX:

   107

                continue

   108

   109

            # pages

   110

            if not file_type:

   111

                continue

   112

   113

            if file_type not in TYPES:

   114

                continue

   115

   116

            yield self.url(page=file_name), file_name, file_type

   117

   118

    def page (self, name):

   119

        """

   120

            Scans through tree looking for a matching page.

   121

   122

            Returns Page.

   123

        """

   124

   125

        if not name:

   126

            name = self.INDEX

   127

   128

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

   129

            # match on name

   130

            if file_name != name:

   131

                continue

   132

   133

            # match on type

   134

            if not file_type:

   135

                continue

   136

   137

            page_type = TYPES.get(file_type)

   138

   139

            if not page_type:

   140

                continue

   141

   142

            # out

   143

            return page_type(

   144

                path    = path,

   145

                name    = name,

   146

                tree    = self,

   147

            )

   148

   149

class Page (object):

   150

    ENCODING = 'utf-8'

   151

   152

    @classmethod

   153

    def lookup (cls, site, page):

   154

        """

   155

            Lookup a Page from disk.

   156

   157

            Returns None if there is no such page.

   158

        """

   159

   160

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

   161

   162

        if page:

   163

            parts = page.split('/')

   164

        else:

   165

            parts = [ ]

   166

   167

        if parts:

   168

            page_name = parts.pop(-1)

   169

            tree_parts = parts

   170

        else:

   171

            page_name = ''

   172

            tree_parts = []

   173

   174

        # scan dir

   175

        tree = Tree.lookup(site, tree_parts)

   176

   177

        if not tree:

   178

            return None

   179

   180

        # scan page

   181

        page = tree.page(page_name)

   182

   183

        if not page:

   184

            return None

   185

   186

        return page

   187

   188

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

   189

        self.path = path

   190

        self.name = name

   191

        self.tree = tree

   192

        self.encoding = encoding

   193

   194

    def url (self):

   195

        return self.tree.url(page=self.name)

   196

   197

    def open (self):

   198

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

   199

   200

    def stat (self):

   201

        return os.stat(self.path)

   202

   203

    def breadcrumb (self):

   204

        for path, name in self.tree.breadcrumb():

   205

            yield path, name

   206

   207

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

   208

            yield self.url(), self.name

   209

   210

    def modified (self):

   211

        return datetime.datetime.utcfromtimestamp(self.stat().st_mtime)

   212

   213

    def render (self, request):

   214

        raise NotImplementedError()

   215

   216

class HTML_Page (Page):

   217

    def render (self, request):

   218

        return self.open().read()

   219

   220

SITE = Site.lookup()

   221

   222

TYPES = {

   223

    'html':         HTML_Page,

   224

}

   225

   226

def page (page):

   227

    return Page.lookup(SITE, page)

   228