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 NotFound (Exception):

     9

    pass

    10

    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):

    28

        """

    29

            Returns Tree

    30

    31

            Raises NotFound

    32

        """

    33

    34

        parents = ( )

    35

        tree = cls(site.root, None, parents, site,

    36

                title       = site.name,

    37

        )

    38

    39

        for name in parts:

    40

            if name.startswith('.'):

    41

                # evil

    42

                raise NotFound()

    43

    44

            if not name:

    45

                continue

    46

    47

            path = os.path.join(tree.path, name)

    48

    49

            if not os.path.exists(path):

    50

                raise NotFound()

    51

    52

            if not os.path.isdir(path):

    53

                raise NotFound()

    54

    58

            parents += (tree, )

    62

    63

        return tree

    64

    65

    def __init__ (self, path, name, parents, site,

    66

            title   = None,

    67

    ):

    68

        """

    69

            path:       filesystem path

    70

            name:       subtree name, or None for root

    71

            parents:    (Tree)

    72

            site:       Site

    73

        """

    74

    75

        self.path = path

    76

        self.name = name

    77

        self.parents = parents

    78

        self.site = site

    79

    80

        self.title = title or name

    81

    82

    def hierarchy (self):

    83

        """

    84

            Yield Tree.

    85

        """

    86

    87

        for tree in self.parents:

    88

            yield tree

    89

    90

        yield self

    91

    92

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

    93

        path = '/'.join(tree.name for tree in self.hierarchy() if tree.name is not None)

    94

    95

        if path:

    96

            path += '/'

    97

    98

        if tree:

    99

            path = tree + '/'

   100

   101

        if page:

   102

            path += page

   103

   104

        return path

   105

   106

    def scan (self):

   107

        """

   108

            Scan for files in tree.

   109

        """

   110

   111

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

   112

            if filename.startswith('.'):

   113

                continue

   114

   115

            if '.' in filename:

   116

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

   117

            else:

   118

                file_name = filename

   119

                file_type = None

   120

   121

            if not file_name:

   122

                continue

   123

   124

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

   125

   126

            yield path, file_name, file_type

   127

   128

    def item_title (self, name):

   129

        """

   130

            Lookup item title if exists.

   131

        """

   132

   133

        title_path = os.path.join(self.path, name + '.title')

   134

   135

        log.info("%s: %s title_path=%s", self, name, title_path)

   136

   137

        if os.path.exists(title_path):

   138

            return open(title_path).read().strip()

   139

        else:

   140

            return None

   141

   142

    def list (self):

   143

        """

   144

            Lists all Trees and Pages for this Tree.

   145

   146

            Yields (name, url, page_type or None, title)

   147

        """

   148

   149

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

   150

            title = self.item_title(name) or name

   151

   152

            # trees

   153

            if os.path.isdir(path):

   154

                yield name, self.url(tree=name), None, title

   155

   156

            if name == self.INDEX:

   157

                continue

   158

   159

            # pages

   160

            if not file_type:

   161

                continue

   162

   163

            if file_type not in TYPES:

   164

                continue

   165

   166

            yield name, self.url(page=name), file_type, title

   167

   168

    def list_sorted (self):

   169

        return sorted(list(self.list()))

   170

   171

    def page (self, name):

   172

        """

   173

            Scans through tree looking for a matching page.

   174

   175

            Returns Page or None.

   176

        """

   177

   178

        if not name:

   179

            name = self.INDEX

   183

   184

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

   185

            # match on name

   186

            if file_name != name:

   187

                continue

   188

   189

            # match on type

   190

            if not file_type:

   191

                continue

   192

   193

            page_type = TYPES.get(file_type)

   194

   195

            if not page_type:

   196

                continue

   197

   198

            # out

   200

   201

            return page_type(

   202

                path    = path,

   203

                name    = name,

   204

                tree    = self,

   205

                parents = self.parents + (self, ),

   206

   207

                title   = title,

   208

            )

   209

   210

class Page (object):

   211

    ENCODING = 'utf-8'

   212

   213

    @classmethod

   214

    def lookup (cls, site, page):

   215

        """

   216

            Returns Page.

   217

   218

            Raises NotFound

   219

        """

   220

   221

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

   222

   223

        if page:

   224

            parts = page.split('/')

   225

        else:

   226

            parts = [ ]

   227

   228

        if parts:

   229

            page_name = parts.pop(-1)

   230

            tree_parts = parts

   231

        else:

   232

            page_name = ''

   233

            tree_parts = []

   234

   235

        # scan dir

   236

        tree = Tree.lookup(site, tree_parts)

   237

   238

        # scan page

   239

        page = tree.page(page_name)

   240

   241

        if not page:

   242

            raise NotFound()

   243

   244

        return page

   245

   246

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

   247

        self.path = path

   248

        self.name = name

   249

        self.tree = tree

   250

        self.parents = parents

   251

   252

        self.encoding = encoding

   253

        self.title = title or name

   254

   255

    def hierarchy (self):

   256

        """

   257

            Yield (Tree, name) pairs

   258

        """

   259

   260

        parent = None

   261

   262

        for tree in self.parents:

   263

            if parent:

   264

                yield parent, tree.name

   265

   266

            parent = tree

   267

   268

        yield parent, self.name

   269

   270

    def url (self):

   271

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

   272

   273

    def open (self):

   274

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

   275

   276

    def stat (self):

   277

        return os.stat(self.path)

   278

   279

    def breadcrumb (self):

   280

        for tree in self.tree.hierarchy():

   281

            yield tree.url(), tree.title

   282

   283

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

   284

            yield self.url(), self.title

   285

   286

    def modified (self):

   287

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

   288

   289

    def render (self, request):

   290

        raise NotImplementedError()

   291

   292

class HTML_Page (Page):

   293

    def render (self, request):

   294

        return self.open().read()

   295

   296

SITE = Site.lookup()

   297

   298

TYPES = {

   299

    'html':         HTML_Page,

   300

}

   301

   302

def page (page):

   303

    return Page.lookup(SITE, page)

   304