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

    18

# path to directory containing the list of visible pages

    19

PAGE_LIST_FILE = os.path.join(PAGE_DIR, "list")

    20

    21

class PageError (http.ResponseError) :

    22

    """

    23

        Error looking up/handling a page

    24

    """

    25

    26

    pass

    27

    28

class PageList (object) :

    29

    """

    30

        The list of pages

    31

    """

    32

    33

    def __init__ (self) :

    34

        """

    35

            Loads the page list from the list file

    36

        """

    37

    38

        # initialize list of pages

    39

        self.pages = []

    40

    41

        # load from file

    42

        self._load(PAGE_LIST_FILE)

    43

    44

    def _load (self, path) :

    45

        """

    46

            Processes the lines in the given file

    47

        """

    48

    49

        for line in open(path, 'rb') :

    50

            # ignore whitespace

    51

            line = line.strip()

    52

    53

            # ignore empty lines

    54

            if not line :

    55

                continue

    56

    57

            # parse line

    58

            url, title = line.split(':')

    59

    60

            # add

    61

            self._add_item(url.strip(), title.strip())

    62

    63

    def _add_item (self, url, title) :

    64

        """

    65

            Add item to pages list

    66

        """

    67

    72

        self.pages.append((url, title))

    73

    74

    def get_title (self, page) :

    75

        """

    76

            Gets the title for the given page, or None if not found

    77

        """

    78

    79

        return dict(self.pages).get(page)

    80

    81

    def get_siblings (self, page) :

    82

        """

    83

            Gets the (url, title) tuple list of siblings (including the given page itself) for the given page

    84

        """

    85

    86

        siblings = []

    87

    88

        # parent url

    89

        parent = os.path.split(page.url)[0]

    90

    91

        # how many segments in the page name

    92

        segment_count = len(page.url.split('/'))

    93

    94

        # go through all pages

    95

        for url, title in self.pages :

    96

            # it's a sibling if the parent is the same, and the number of segments it the same

    97

            if url.startswith(parent) and len(url.split('/')) == segment_count :

    98

                siblings.append((url, title))

    99

   100

        # return

   101

        return siblings

   102

   103

# global singleton instance

   104

page_list = PageList()

   105

   106

class Page (object) :

   107

    """

   108

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

   109

    """

   110

   111

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

   112

        """

   113

            Initialize the page at the given location

   114

   115

            @param url the URL leading to this page

   116

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

   117

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

   118

            @param url_trail trailing URL for this page

   119

        """

   120

   121

        # store

   122

        self.url = url

   123

        self.path = path

   124

        self.basename = basename

   125

        self.url_tail = url_tail

   126

   130

        # sub-init

   131

        self._init()

   132

   133

    def _init (self) :

   134

        """

   135

            Do initial data loading, etc

   136

        """

   137

   138

        pass

   139

   147

    @property

   148

    def title (self) :

   149

        """

   150

            Return the page's title

   151

   152

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

   153

        """

   154

   155

        # lookup in page_list

   156

        title = page_list.get_title(self.url)

   157

   158

        # fallback to titlecase

   159

        if not title :

   160

            title = self.basename.title()

   161

   162

        return title

   163

   164

    @property

   165

    def content (self) :

   166

        """

   167

            Return the page content as a string

   168

        """

   169

   170

        abstract

   171

   172

class HTMLPage (Page) :

   173

    """

   174

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

   175

    """

   176

   177

    @property

   178

    def content (self) :

   179

        """

   180

            Opens the .html file, reads and returns contents

   181

        """

   182

   183

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

   184

   185

class TemplatePage (Page) :

   186

    """

   187

        A template that's rendered using our template library

   188

    """

   189

   190

    @property

   191

    def content (self) :

   192

        """

   193

            Loads the .tmpl file, and renders it

   194

        """

   195

   199

   200

# list of page handlers, by type

   201

TYPE_HANDLERS = [

   202

    ('html',                    HTMLPage        ),

   203

    (template.TEMPLATE_EXT,     TemplatePage    ),

   204

]

   205

   206

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

   207

    """

   208

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

   209

    """

   210

   211

    # find appropriate handler

   212

    for handler_ext, handler in TYPE_HANDLERS :

   213

        # match against file extension?

   214

        if handler_ext == extension :

   215

            # found handler, return instance

   216

            return handler(url, path, basename, tail)

   217

   218

    # no handler found

   219

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

   220

   221

def lookup (name) :

   222

    """

   223

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

   224

    """

   225

   226

    # inital path

   227

    path = PAGE_DIR

   228

    url_segments = []

   229

   230

    # name segments

   231

    segments = name.split('/')

   232

   233

    # iterate through the parts of the page segments

   237

        # pop segment

   240

   242

   243

        # translate empty -> index

   244

        if not segment :

   245

            segment = 'index'

   247

        # look for it in the dir

   248

        for filename in os.listdir(path) :

   249

            # build full file path

   250

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

   251

   252

            # stat, recurse into subdirectory?

   253

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

   254

                # use new dir

   255

                path = file_path

   256

   257

                # break for-loop to look at next segment

   258

                break

   259

   260

            # split into basename + extension

   261

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

   262

   263

            # ...remove that dot

   264

            extension = extension.lstrip('.')

   265

   266

            # match against requested page name?

   267

            if basename == segment :

   268

                # found the file we wanted

   269

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

   270

   271

            else :

   272

                # inspect next file in dir

   273

                continue

   274

   279

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

   280

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

   281