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

    55

            # title

    56

            title = tree.item_title(name)

    57

    58

            parents += (tree, )

    59

            tree = cls(path, name, parents, site,

    60

                    title   = title,

    61

            )

    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

   180

            title_default = self.title

   181

        else:

   182

            title_default = None

   183

   186

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

   187

            # match on name

   189

                continue

   204

   205

            # match on type

   206

            if not file_type:

   207

                continue

   208

   209

            page_type = TYPES.get(file_type)

   210

   211

            if not page_type:

   212

                continue

   213

   214

            # out

   215

            title = self.item_title(file_name) or title_default

   216

   218

                title   = title,

   219

            )

   220

   221

class Page (object):

   222

    ENCODING = 'utf-8'

   223

   224

    @classmethod

   225

    def lookup (cls, site, page):

   226

        """

   227

            Returns Page.

   228

   229

            Raises NotFound

   230

        """

   231

   232

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

   233

   234

        if page:

   235

            parts = page.split('/')

   236

        else:

   237

            parts = [ ]

   238

   239

        if parts:

   240

            page_name = parts.pop(-1)

   241

            tree_parts = parts

   242

        else:

   243

            page_name = ''

   244

            tree_parts = []

   245

   246

        # scan dir

   247

        tree = Tree.lookup(site, tree_parts)

   248

   249

        # scan page

   250

        page = tree.page(page_name)

   251

   252

        if not page:

   253

            raise NotFound()

   254

   255

        return page

   256

   257

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

   258

        self.path = path

   259

        self.name = name

   260

        self.tree = tree

   261

        self.parents = parents

   262

   263

        self.encoding = encoding

   264

        self.title = title or name

   265

   266

    def hierarchy (self):

   267

        """

   268

            Yield (Tree, name) pairs

   269

        """

   270

   271

        parent = None

   272

   273

        for tree in self.parents:

   274

            if parent:

   275

                yield parent, tree.name

   276

   277

            parent = tree

   278

   279

        yield parent, self.name

   280

   281

    def url (self):

   282

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

   283

   284

    def open (self):

   285

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

   286

   287

    def stat (self):

   288

        return os.stat(self.path)

   289

   290

    def breadcrumb (self):

   291

        for tree in self.tree.hierarchy():

   292

            yield tree.url(), tree.title

   293

   294

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

   295

            yield self.url(), self.title

   296

   297

    def modified (self):

   298

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

   299

   304

        raise NotImplementedError()

   305

   319

class HTML_Page (Page):

   321

        return self.open().read()

   322

   323

SITE = Site.lookup()

   324

   325

TYPES = {

   326

    'html':         HTML_Page,

   327

}

   328

   329

def page (page):

   330

    return Page.lookup(SITE, page)

   331