1

     2

"""

     3

    Handling page requests

     4

"""

     5

     6

# for filesystem ops

     7

import os, os.path

     8

import time

     9

    10

# for ResponseError

    11

import http

    12

    13

# for TemplatePage

    14

import template

    15

    16

from page_tree import page_tree

    17

    18

# path to directory containing the page heirarcy

    19

PAGE_DIR = "pages"

    20

    21

class PageError (http.ResponseError) :

    22

    """

    23

        Error looking up/handling a page

    24

    """

    25

    26

    pass

    27

    28

# XXX: should inherit from PageInfo

    29

class Page (object) :

    30

    """

    31

        This object represents the information about our attempt to render some specific page

    32

    """

    33

    34

    def __init__ (self, url, path, basename, url_tail, charset='utf8') :

    35

        """

    36

            Initialize the page at the given location

    37

    38

            @param url the URL leading to this page

    39

            @param path the filesystem path to this page's file

    40

            @param basename the filesystem name of this page's file, without the file extension

    41

            @param url_trail trailing URL for this page

    42

            @param charset file charset

    43

        """

    44

    45

        # store

    46

        self.url = url

    47

        self.path = path

    48

        self.basename = basename

    49

        self.url_tail = url_tail

    50

        self.charset = charset

    51

    52

        # unbound

    53

        self.request = None

    54

    55

        # sub-init

    56

        self._init()

    57

    58

    def _init (self) :

    59

        """

    60

            Do initial data loading, etc

    61

        """

    62

    63

        pass

    64

    65

    def bind_request (self, request) :

    66

        """

    67

            Bind this page-render to the given request

    68

        """

    69

    70

        self.request = request

    71

    72

    @property

    73

    def title (self) :

    74

        """

    75

            Return the page's title

    76

    77

            Defaults to the retreiving the page title from page_list, or basename in Titlecase.

    78

        """

    79

    80

        # lookup in page_list

    81

        page_info = page_tree.get_page(self.url)

    82

    83

        # fallback to titlecase

    84

        if page_info :

    85

            title = page_info.title

    86

    87

        else :

    88

            title = self.basename.title()

    89

    90

        return title

    91

    92

    @property

    93

    def content (self) :

    94

        """

    95

            Return the page content as a string

    96

        """

    97

    98

        abstract

    99

   100

    @property

   101

    def modified (self) :

   102

        """

   103

            Returns the page modification timestamp

   104

        """

   105

   106

        # stat

   107

        timestamp = os.stat(self.path).st_mtime

   108

   109

        return time.strftime("%Y/%m/%d %H:%M %Z", time.gmtime(timestamp))

   110

   111

class HTMLPage (Page) :

   112

    """

   113

        A simple .html page that's just passed through directly

   114

    """

   115

   116

    @property

   117

    def content (self) :

   118

        """

   119

            Opens the .html file, reads and returns contents

   120

        """

   121

   122

        return open(self.path, 'rb').read().decode(self.charset)

   123

   124

class TemplatePage (Page) :

   125

    """

   126

        A template that's rendered using our template library

   127

    """

   128

   129

    @property

   130

    def content (self) :

   131

        """

   132

            Loads the .tmpl file, and renders it

   133

        """

   134

   135

        return template.render_file(self.path,

   136

            request     = self.request,

   137

            page_tree   = page_tree

   138

        )

   139

   140

# list of page handlers, by type

   141

TYPE_HANDLERS = [

   142

    ('html',                    HTMLPage        ),

   143

    (template.TEMPLATE_EXT,     TemplatePage    ),

   144

]

   145

   146

def _lookup_handler (url, path, filename, basename, extension, tail) :

   147

    """

   148

        We found the file that we looked for, now get its handler

   149

    """

   150

   151

    # find appropriate handler

   152

    for handler_ext, handler in TYPE_HANDLERS :

   153

        # match against file extension?

   154

        if handler_ext == extension :

   155

            # found handler, return instance

   156

            return handler(url, path, basename, tail)

   157

   158

    # no handler found

   159

    raise PageError("No handler found for page %r of type %r" % (url, extension))

   160

   161

def lookup (name) :

   162

    """

   163

        Look up and return a Page object for the given page, or raise an error

   164

    """

   165

   166

    # inital path

   167

    path = PAGE_DIR

   168

    url_segments = []

   169

   170

    # name segments

   171

    segments = name.split('/')

   172

   173

    # iterate through the parts of the page segments

   174

    while True :

   175

        segment = None

   176

   177

        # pop segment

   178

        if segments :

   179

            segment = segments.pop(0)

   180

   181

            url_segments.append(segment)

   182

   183

        # translate empty -> index

   184

        if not segment :

   185

            segment = 'index'

   186

   187

        # look for it in the dir

   188

        for filename in os.listdir(path) :

   189

            # build full file path

   190

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

   191

   192

            # stat, recurse into subdirectory?

   193

            if os.path.isdir(file_path) and filename == segment :

   194

                # use new dir

   195

                path = file_path

   196

   197

                # break for-loop to look at next segment

   198

                break

   199

   200

            # split into basename + extension

   201

            basename, extension = os.path.splitext(filename)

   202

   203

            # ...remove that dot

   204

            extension = extension.lstrip('.')

   205

   206

            # match against requested page name?

   207

            if basename == segment :

   208

                # found the file we wanted

   209

                return _lookup_handler('/'.join(url_segments), file_path, filename, basename, extension, '/'.join(segments))

   210

   211

            else :

   212

                # inspect next file in dir

   213

                continue

   214

   215

        else :

   216

            # did not find any dir or file, break out of while loop

   217

            break

   218

   219

    # did not find the filename we were looking for in os.listdir

   220

    raise PageError("Page not found: %s" % name, status='404 Not Found')

   221