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

# path to directory containing the page heirarcy

    16

PAGE_DIR = "pages"

    17

    21

class PageError (http.ResponseError) :

    22

    """

    23

        Error looking up/handling a page

    24

    """

    25

    26

    pass

    27

   102

class Page (object) :

   103

    """

   104

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

   105

    """

   106

   107

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

   108

        """

   109

            Initialize the page at the given location

   110

   111

            @param url the URL leading to this page

   112

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

   113

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

   114

            @param url_trail trailing URL for this page

   115

        """

   116

   117

        # store

   118

        self.url = url

   119

        self.path = path

   120

        self.basename = basename

   121

        self.url_tail = url_tail

   122

   123

        # sub-init

   124

        self._init()

   125

   126

    def _init (self) :

   127

        """

   128

            Do initial data loading, etc

   129

        """

   130

   131

        pass

   132

   135

        """

   136

            Return the page's title

   137

   139

        """

   147

   152

        """

   153

            Return the page content as a string

   154

        """

   155

   156

        abstract

   157

   158

class HTMLPage (Page) :

   159

    """

   160

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

   161

    """

   162

   165

        """

   166

            Opens the .html file, reads and returns contents

   167

        """

   168

   169

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

   170

   171

class TemplatePage (Page) :

   172

    """

   173

        A template that's rendered using our template library

   174

    """

   178

        """

   179

            Loads the .tmpl file, and renders it

   180

        """

   181

   182

        return template.render_file(self.path)

   183

   184

# list of page handlers, by type

   185

TYPE_HANDLERS = [

   186

    ('html',                    HTMLPage        ),

   187

    (template.TEMPLATE_EXT,     TemplatePage    ),

   188

]

   189

   190

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

   191

    """

   192

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

   193

    """

   194

   195

    # find appropriate handler

   196

    for handler_ext, handler in TYPE_HANDLERS :

   197

        # match against file extension?

   198

        if handler_ext == extension :

   199

            # found handler, return instance

   200

            return handler(url, path, basename, tail)

   201

   202

    # no handler found

   203

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

   204

   205

def lookup (name) :

   206

    """

   207

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

   208

    """

   209

   210

    # inital path

   211

    path = PAGE_DIR

   212

    url_segments = []

   213

   214

    # name segments

   215

    segments = name.split('/')

   216

   217

    # iterate through the parts of the page segments

   218

    while segments :

   219

        # pop segment

   220

        segment = segments.pop(0)

   221

   222

        # add to page url

   223

        url_segments.append(segment)

   224

   225

        # translate empty -> index

   226

        if not segment :

   227

            segment = 'index'

   228

   229

        # look for it in the dir

   230

        for filename in os.listdir(path) :

   231

            # build full file path

   232

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

   233

   234

            # stat, recurse into subdirectory?

   235

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

   236

                # use new dir

   237

                path = file_path

   238

   239

                # break for-loop to look at next segment

   240

                break

   241

   242

            # split into basename + extension

   243

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

   244

   245

            # ...remove that dot

   246

            extension = extension.lstrip('.')

   247

   248

            # match against requested page name?

   249

            if basename == segment :

   250

                # found the file we wanted

   251

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

   252

   253

            else :

   254

                # inspect next file in dir

   255

                continue

   256

   257

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

   258

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

   259