1

import werkzeug

     2

from werkzeug import exceptions

     3

from werkzeug import Request, Response

     4

from werkzeug.routing import Map, Rule

     5

     6

import logging

     7

     8

# logging

     9

log = logging.getLogger('svv.wsgi')

    10

    11

class AppHandler (object):

    12

    """

    13

        Per-request handler type, containing the request context and implementing the response.

    14

    15

        Works on a generic level, i.e. WSGI/Werkzeug URL-mapped request in, response out.

    16

    """

    17

    18

    # default content type for response

    19

    CONTENT_TYPE = 'text/html'

    20

    21

    def __init__ (self, request) :

    22

        """

    23

            Initialize for processing the given Request, to prepare for action-method later on

    24

        """

    25

    26

        self.request = request

    27

    28

    def respond (self, url_values) :

    29

        """

    30

            Handle request that was mapped to ourselves via the URL routing, using given dict of values from URL.

    31

        """

    32

    33

        raise NotImplementedError()

    34

    35

import html

    36

from html import tags

    37

    38

class PageHandler (AppHandler) :

    39

    """

    40

        Specialized AppHandler for normal HTML page views.

    41

    42

        Renders the layout template and HTML.

    43

    """

    44

    45

    def respond (self, url_values) :

    46

        title = "Index"

    47

        css = ["/static/layout.css", "/static/style.css", "/static/treelist.css"]

    48

        scripts = [

    49

                "/static/js/prototype.js", 

    50

                "/static/js/scriptaculous/scriptaculous.js", 

    51

                "/static/js/treelist.js"

    52

        ]

    53

    54

        head = (

    55

            tags.title(title),

    56

            (tags.link(rel='Stylesheet', type="text/css", href=src) for src in css),

    57

            # XXX: script can't self-close >_<

    58

            (tags.script(src=src)(" ") for src in scripts),

    59

        )

    60

    61

        header = ("Foo List")

    62

        nav = [tags.ul(tags.li(tags.a(href='#')(name)) for name in ['Nav A', 'Nav B', 'Nav C'])]

    63

        menu = [tags.ul(tags.li(tags.a(href='#')(name)) for name in ['Menu A', 'Menu B', 'Menu C'])]

    64

        footer = ("Copyright?")

    65

    66

        # render page HTML

    67

        content = self.render(**url_values)

    68

    69

        layout = (

    70

            tags.div(id='header')(header),

    71

            tags.div(id='container')(

    72

                tags.div(id='menu')(menu),

    73

                tags.div(id='nav')(nav),

    74

                tags.div(id='content')(content),

    75

            ),

    76

            tags.div(id='footer')(footer),

    77

        )

    78

    79

        # perform the actual rendering (run generators etc.)

    80

        html_text = unicode(html.document(head, layout))

    81

    82

        # response object

    83

        # XXX: unicode?

    84

        return Response(html_text, mimetype='text/html')

    85

    86

    def render (self, **args) :

    87

        """

    88

            Render and return HTML for page content.

    89

    90

            XXX: must be HTML object, support just text?

    91

        """

    92

    93

        raise NotImplementedError()

    94

   125

class Index (PageHandler) :

   126

    DATA = (

   127

        (100, "Top A", []),

   128

        (200, "Top B", [

   129

            (210, "Mid BA", [

   130

                (211, "Sub BAA", []),

   131

                (212, "Sub BAB", []),

   132

            ]),

   133

            (220, "Mid BB", []),

   134

        ]),

   135

        (300, "Top C", [

   136

            (310, "Mid CA", []),

   137

            (320, "Mid CB", []),

   138

        ]),

   139

    )

   140

   141

    def render (self) :

   142

        # build data set

   143

        data = self.DATA

   144

   145

        def render_item (id, text, children) :

   146

            return tags.li(

   147

                tags.div(class_='item')(

   148

                    # item text

   149

                    tags.a(tags.input(type='checkbox', name_=id, checked=(

   150

                        'checked' if self.request.form.get(str(id)) else None

   151

                    )), text, class_='text'),

   152

                ),

   153

   154

                # children

   155

                tags.ul(render_item(*item) for item in children if item) if children else None,

   156

   157

                # 

   158

                class_=('more open' if children else None),

   159

            )

   160

   161

        # render it

   162

        return (

   163

            tags.h3("Item list"),

   164

            tags.form(action='.', method='post')(

   165

                tags.ul(class_='treelist')(render_item(*item) for item in data),

   166

                tags.input(type='submit'),

   167

            ),

   168

        )

   169

   170

   171

class WSGIApp (object) :

   172

    """

   173

        Top-level WSGI handler impl

   174

    """

   175

   176

    # URL paths

   177

    # map to AppHandler-endpoint

   178

    URLS = Map((

   179

        Rule('/', endpoint=Index),

   181

    ))

   182

   183

    def __init__ (self) :

   184

        pass

   185

   186

    # wrap to use werkzeug's Request/Response

   187

    @Request.application

   188

    def __call__ (self, req) :

   189

        """

   190

            Main WSGI entry point, error handling

   191

        """

   192

   193

        try :

   194

            # wrapped handler

   195

            response = self.request(req)

   196

   197

        except exceptions.HTTPException, e :

   198

            # format properly as response, also includes redirects

   199

            return e.get_response(req.environ)

   200

   201

        # XXX: except Exception, e :

   202

        # XXX: we want to trap errors in prod, but not in dev?

   203

   204

        else :

   205

            # a-ok

   206

            return response

   207

   208

    def request (self, req) :

   209

        """

   210

            Wrapped request handler, URL mapping

   211

        """

   212

   213

        # map URLs against this request

   214

        urls = self.URLS.bind_to_environ(req)

   215

   216

        # lookup matching URL for handler type and matched values from URL

   217

        url_handler, url_values = urls.match()

   218

   219

        # the per-request handler (from endpoint)

   220

        req_handler = url_handler(req)

   221

   222

        # XXX: per-method thing?

   223

        response = req_handler.respond(url_values)

   224

   225

        # ok

   226

        return response

   227

   228