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

import markdown

    10

    11

class NotFound (Exception):

    12

    pass

    13

    17

class Site (object):

    18

    @classmethod

    19

    def lookup (cls):

    20

        return cls(

    21

            root        = settings.QMSK_WWW_PAGES_DIR,

    22

            name        = settings.QMSK_WWW_PAGES_SITE,

    23

        )

    24

    25

    def __init__ (self, root, name):

    26

        self.root = root

    27

        self.name = name

    28

    29

class Tree (object):

    30

    INDEX = 'index'

    31

    32

    @classmethod

    33

    def lookup (cls, site, parts):

    34

        """

    35

            Returns Tree

    36

    37

            Raises NotFound

    38

        """

    39

    40

        parents = ( )

    41

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

    42

                title       = site.name,

    43

        )

    44

    45

        for name in parts:

    46

            if name.startswith('.'):

    47

                # evil

    48

                raise NotFound()

    49

    50

            if not name:

    51

                continue

    52

    53

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

    54

    55

            if not os.path.exists(path):

    56

                raise NotFound()

    57

    58

            if not os.path.isdir(path):

    59

                raise NotFound()

    60

    61

            # title

    62

            title = tree.item_title(name)

    63

    64

            parents += (tree, )

    65

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

    66

                    title   = title,

    67

            )

    68

    69

        return tree

    70

    71

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

    72

            title   = None,

    73

    ):

    74

        """

    75

            path:       filesystem path

    76

            name:       subtree name, or None for root

    77

            parents:    (Tree)

    78

            site:       Site

    79

        """

    80

    81

        self.path = path

    82

        self.name = name

    83

        self.parents = parents

    84

        self.site = site

    85

    86

        self.title = title or name

    87

    88

    def hierarchy (self):

    89

        """

    90

            Yield Tree.

    91

        """

    92

    93

        for tree in self.parents:

    94

            yield tree

    95

    96

        yield self

    97

    98

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

    99

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

   100

   101

        if path:

   102

            path += '/'

   103

   104

        if tree:

   105

            path = tree + '/'

   106

   107

        if page:

   108

            path += page

   109

   110

        return path

   111

   112

    def scan (self):

   113

        """

   114

            Scan for files in tree.

   115

        """

   116

   117

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

   118

            if filename.startswith('.'):

   119

                continue

   120

   121

            if '.' in filename:

   122

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

   123

            else:

   124

                file_name = filename

   125

                file_type = None

   126

   127

            if not file_name:

   128

                continue

   129

   130

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

   131

   132

            yield path, file_name, file_type

   133

   134

    def item_title (self, name):

   135

        """

   136

            Lookup item title if exists.

   137

        """

   138

   139

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

   140

   141

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

   142

   143

        if os.path.exists(title_path):

   144

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

   145

        else:

   146

            return None

   147

   148

    def list (self):

   149

        """

   150

            Lists all Trees and Pages for this Tree.

   151

   152

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

   153

        """

   154

   155

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

   156

            title = self.item_title(name) or name

   157

   158

            # trees

   159

            if os.path.isdir(path):

   160

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

   161

   162

            if name == self.INDEX:

   163

                continue

   164

   165

            # pages

   166

            if not file_type:

   167

                continue

   168

   169

            if file_type not in TYPES:

   170

                continue

   171

   172

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

   173

   174

    def list_sorted (self):

   175

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

   176

   177

    def page (self, name):

   178

        """

   179

            Scans through tree looking for a matching page.

   180

   181

            Returns Page or None.

   182

        """

   183

   184

        if not name:

   185

            name = self.INDEX

   186

            title_default = self.title

   187

        else:

   188

            title_default = None

   189

   190

        parents = self.parents + (self, )

   191

   192

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

   193

            # match on name

   194

            if file_name == name:

   195

                pass

   196

            elif file_type and (file_name + '.' + file_type == name):

   197

                pass

   198

            else:

   199

                continue

   200

   201

            # redirects?

   202

            if os.path.islink(path):

   203

                target = os.readlink(path)

   204

   205

                # XXX: this should be some kind of common code

   206

                if '.' in target:

   207

                    target, target_type = target.rsplit('.', 1)

   208

   209

                log.info("%s: %s -> %s", self, name, target)

   210

   211

                return RedirectPage(path, name, self, parents,

   212

                    target  = target,

   213

                )

   214

   215

            # match on type

   216

            if not file_type:

   217

                continue

   218

   219

            page_type = TYPES.get(file_type)

   220

   221

            if not page_type:

   222

                continue

   223

   224

            # out

   225

            title = self.item_title(file_name) or title_default

   226

   227

            return page_type(path, name, self, parents,

   228

                title   = title,

   229

            )

   230

   231

class Page (object):

   232

    ENCODING = 'utf-8'

   233

   234

    @classmethod

   235

    def lookup (cls, site, page):

   236

        """

   237

            Returns Page.

   238

   239

            Raises NotFound

   240

        """

   241

   242

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

   243

   244

        if page:

   245

            parts = page.split('/')

   246

        else:

   247

            parts = [ ]

   248

   249

        if parts:

   250

            page_name = parts.pop(-1)

   251

            tree_parts = parts

   252

        else:

   253

            page_name = ''

   254

            tree_parts = []

   255

   256

        # scan dir

   257

        tree = Tree.lookup(site, tree_parts)

   258

   259

        # scan page

   260

        page = tree.page(page_name)

   261

   262

        if not page:

   263

            raise NotFound()

   264

   265

        return page

   266

   267

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

   268

        self.path = path

   269

        self.name = name

   270

        self.tree = tree

   271

        self.parents = parents

   272

   273

        self.encoding = encoding

   274

        self.title = title or name

   275

   276

    def hierarchy (self):

   277

        """

   278

            Yield (Tree, name) pairs

   279

        """

   280

   281

        parent = None

   282

   283

        for tree in self.parents:

   284

            if parent:

   285

                yield parent, tree.name

   286

   287

            parent = tree

   288

   289

        yield parent, self.name

   290

   291

    def url (self):

   292

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

   293

   294

    def open (self):

   295

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

   296

   297

    def stat (self):

   298

        return os.stat(self.path)

   299

   300

    def breadcrumb (self):

   301

        for tree in self.tree.hierarchy():

   302

            yield tree.url(), tree.title

   303

   304

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

   305

            yield self.url(), self.title

   306

   307

    def modified (self):

   308

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

   309

   310

    def redirect_page (self, request):

   311

        return None

   312

   313

    def render_html (self, request):

   314

        raise NotImplementedError()

   315

   316

# TODO: tree redirects

   317

class RedirectPage (Page):

   318

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

   319

            target,

   320

            **opts

   321

    ) :

   322

        super(RedirectPage, self).__init__(path, name, tree, parents, **opts)

   323

   324

        self.target = target

   325

   326

    def redirect_page (self, request):

   327

        return os.path.normpath(self.tree.url() + '/' + self.target)

   328

   329

class HTML_Page (Page):

   330

    def render_html (self, request):

   331

        return self.open().read()

   332

   333

class MarkdownPage (Page):

   334

    FORMAT = 'html5'

   335

   336

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

   337

            format=FORMAT,

   338

            **opts

   339

    ) :

   340

        super(MarkdownPage, self).__init__(path, name, tree, parents, **opts)

   341

   342

        self.format = format

   343

   344

    def render_html (self, request):

   345

        return markdown.markdown(self.open().read(),

   346

            output_format   = self.format,

   347

        )

   348

   363

SITE = Site.lookup()

   364

   365

TYPES = {

   366

    'html':         HTML_Page,

   367

    'md':           MarkdownPage,

   368

    'markdown':     MarkdownPage,

   370

}

   371

   372

def page (page):

   373

    return Page.lookup(SITE, page)

   374