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

    11

class Site (object):

    12

    @classmethod

    13

    def lookup (cls):

    14

        return cls(

    15

            root        = settings.QMSK_WWW_PAGES_DIR,

    16

            name        = settings.QMSK_WWW_PAGES_SITE,

    17

        )

    18

    19

    def __init__ (self, root, name):

    20

        self.root = root

    21

        self.name = name

    22

    23

class Tree (object):

    24

    INDEX = 'index'

    25

    26

    @classmethod

    27

    def lookup (cls, site, parts):

    30

    41

                # evil

    43

    45

                continue

    46

    48

    49

            if not os.path.exists(path):

    51

    52

            if not os.path.isdir(path):

    54

    70

        self.path = path

    73

        self.site = site

    74

    87

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

    89

    90

        if path:

    91

            path += '/'

    92

    93

        if tree:

    94

            path = tree + '/'

    95

    96

        if page:

    97

            path += page

    98

    99

        return path

   100

   101

    def scan (self):

   102

        """

   103

            Scan for files in tree.

   104

        """

   105

   106

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

   107

            if filename.startswith('.'):

   108

                continue

   109

   110

            if '.' in filename:

   111

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

   112

            else:

   113

                file_name = filename

   114

                file_type = None

   115

   116

            if not file_name:

   117

                continue

   118

   119

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

   120

   121

            yield path, file_name, file_type

   122

   123

    def list (self):

   124

        """

   125

            Lists all Trees and Pages for this Tree

   126

        """

   127

   128

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

   129

            # trees

   130

            if os.path.isdir(path):

   131

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

   132

   133

            if file_name == self.INDEX:

   134

                continue

   135

   136

            # pages

   137

            if not file_type:

   138

                continue

   139

   140

            if file_type not in TYPES:

   141

                continue

   142

   143

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

   144

   145

    def page (self, name):

   146

        """

   147

            Scans through tree looking for a matching page.

   148

   150

        """

   151

   152

        if not name:

   153

            name = self.INDEX

   154

   155

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

   156

            # match on name

   157

            if file_name != name:

   158

                continue

   159

   160

            # match on type

   161

            if not file_type:

   162

                continue

   163

   164

            page_type = TYPES.get(file_type)

   165

   166

            if not page_type:

   167

                continue

   168

   169

            # out

   170

            return page_type(

   171

                path    = path,

   172

                name    = name,

   173

                tree    = self,

   175

            )

   176

   177

class Page (object):

   178

    ENCODING = 'utf-8'

   179

   180

    @classmethod

   181

    def lookup (cls, site, page):

   182

        """

   186

        """

   187

   188

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

   189

   190

        if page:

   191

            parts = page.split('/')

   192

        else:

   193

            parts = [ ]

   194

   195

        if parts:

   196

            page_name = parts.pop(-1)

   197

            tree_parts = parts

   198

        else:

   199

            page_name = ''

   200

            tree_parts = []

   201

   202

        # scan dir

   203

        tree = Tree.lookup(site, tree_parts)

   204

   205

        # scan page

   206

        page = tree.page(page_name)

   207

   208

        if not page:

   210

   211

        return page

   212

   214

        self.path = path

   215

        self.name = name

   216

        self.tree = tree

   219

        self.encoding = encoding

   221

   222

    def url (self):

   223

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

   224

   225

    def open (self):

   226

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

   227

   228

    def stat (self):

   229

        return os.stat(self.path)

   230

   231

    def breadcrumb (self):

   234

   235

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

   237

   238

    def modified (self):

   239

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

   240

   241

    def render (self, request):

   242

        raise NotImplementedError()

   243

   244

class HTML_Page (Page):

   245

    def render (self, request):

   246

        return self.open().read()

   247

   248

SITE = Site.lookup()

   249

   250

TYPES = {

   251

    'html':         HTML_Page,

   252

}

   253

   254

def page (page):

   255

    return Page.lookup(SITE, page)

   256