1

     2

"""

     3

    Handling page requests

     4

"""

     5

     6

# for filesystem ops

     7

import os, os.path

     8

     9

# for ResponseError

    10

import http

    11

    12

# for TemplatePage

    13

import template

    14

    15

from page_tree import page_tree

    16

    17

# path to directory containing the page heirarcy

    18

PAGE_DIR = "pages"

    19

    20

class PageError (http.ResponseError) :

    21

    """

    22

        Error looking up/handling a page

    23

    """

    24

    25

    pass

    26

    27

# XXX: should inherit from PageInfo

    28

class Page (object) :

    29

    """

    30

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

    31

    """

    32

    33

    def __init__ (self, url, path, basename, url_tail) :

    34

        """

    35

            Initialize the page at the given location

    36

    37

            @param url the URL leading to this page

    38

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

    39

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

    40

            @param url_trail trailing URL for this page

    41

        """

    42

    43

        # store

    44

        self.url = url

    45

        self.path = path

    46

        self.basename = basename

    47

        self.url_tail = url_tail

    48

    49

        # unbound

    50

        self.request = None

    51

    52

        # sub-init

    53

        self._init()

    54

    55

    def _init (self) :

    56

        """

    57

            Do initial data loading, etc

    58

        """

    59

    60

        pass

    61

    62

    def bind_request (self, request) :

    63

        """

    64

            Bind this page-render to the given request

    65

        """

    66

    67

        self.request = request

    68

    69

    @property

    70

    def title (self) :

    71

        """

    72

            Return the page's title

    73

    74

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

    75

        """

    76

    77

        # lookup in page_list

    78

        page_info = page_tree.get_page(self.url)

    79

    80

        # fallback to titlecase

    81

        if page_info :

    82

            title = page_info.title

    83

    84

        else :

    85

            title = self.basename.title()

    86

    87

        return title

    88

    89

    @property

    90

    def content (self) :

    91

        """

    92

            Return the page content as a string

    93

        """

    94

    95

        abstract

    96

    97

class HTMLPage (Page) :

    98

    """

    99

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

   100

    """

   101

   102

    @property

   103

    def content (self) :

   104

        """

   105

            Opens the .html file, reads and returns contents

   106

        """

   107

   108

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

   109

   110

class TemplatePage (Page) :

   111

    """

   112

        A template that's rendered using our template library

   113

    """

   114

   115

    @property

   116

    def content (self) :

   117

        """

   118

            Loads the .tmpl file, and renders it

   119

        """

   120

   121

        return template.render_file(self.path,

   122

            request     = self.request,

   123

            page_tree   = page_tree

   124

        )

   125

   126

# list of page handlers, by type

   127

TYPE_HANDLERS = [

   128

    ('html',                    HTMLPage        ),

   129

    (template.TEMPLATE_EXT,     TemplatePage    ),

   130

]

   131

   132

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

   133

    """

   134

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

   135

    """

   136

   137

    # find appropriate handler

   138

    for handler_ext, handler in TYPE_HANDLERS :

   139

        # match against file extension?

   140

        if handler_ext == extension :

   141

            # found handler, return instance

   142

            return handler(url, path, basename, tail)

   143

   144

    # no handler found

   145

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

   146

   147

def lookup (name) :

   148

    """

   149

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

   150

    """

   151

   152

    # inital path

   153

    path = PAGE_DIR

   154

    url_segments = []

   155

   156

    # name segments

   157

    segments = name.split('/')

   158

   159

    # iterate through the parts of the page segments

   160

    while True :

   161

        segment = None

   162

   163

        # pop segment

   164

        if segments :

   165

            segment = segments.pop(0)

   166

   167

            url_segments.append(segment)

   168

   169

        # translate empty -> index

   170

        if not segment :

   171

            segment = 'index'

   172

   173

        # look for it in the dir

   174

        for filename in os.listdir(path) :

   175

            # build full file path

   176

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

   177

   178

            # stat, recurse into subdirectory?

   179

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

   180

                # use new dir

   181

                path = file_path

   182

   183

                # break for-loop to look at next segment

   184

                break

   185

   186

            # split into basename + extension

   187

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

   188

   189

            # ...remove that dot

   190

            extension = extension.lstrip('.')

   191

   192

            # match against requested page name?

   193

            if basename == segment :

   194

                # found the file we wanted

   195

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

   196

   197

            else :

   198

                # inspect next file in dir

   199

                continue

   200

   201

        else :

   202

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

   203

            break

   204

   205

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

   206

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

   207