1

     2

"""

     3

    URL mapping for the irclogs.qmsk.net site

     4

"""

     5

     6

import re

     8

     9

# our own handlers

    10

import handlers

    11

    12

# mapper

    13

from lib import map

    14

    15

class URLError (Exception) :

    16

    """

    17

        Error with an URL definition

    18

    """

    19

    20

    pass

    21

    41

class Label (object) :

    42

    """

    43

        Base class for URL labels (i.e. the segments of the URL between /s)

    44

    """

    45

    46

    @staticmethod

    47

    def parse (mask, defaults) :

    48

        """

    49

            Parse the given label-segment, and return a *Label instance

    50

        """

    51

    52

        # empty?

    53

        if not mask :

    54

            return EmptyLabel()

    55

    56

        # simple value?

    57

        match = SimpleValueLabel.EXPR.match(mask)

    58

    59

        if match :

    60

            # key

    61

            key = match.group('key')

    62

    63

            # default?

    64

            default = defaults.get(key)

    65

    66

            # build

    67

            return SimpleValueLabel(key, default)

    68

    69

        # static?

    70

        match = StaticLabel.EXPR.match(mask)

    71

    72

        if match :

    73

            return StaticLabel(match.group('name'))

    74

    75

        # invalid

    76

        raise URLError("Invalid label: %r" % (mask, ))

    83

    85

    86

class EmptyLabel (Label) :

    87

    """

    88

        An empty label, i.e. just a slash in the URL

    89

    """

    90

    91

    def __eq__ (self, other) :

    92

        """

    93

            Just compares type

    94

        """

    95

    96

        return isinstance(other, EmptyLabel)

    97

   106

    def __str__ (self) :

   107

        return ''

   108

   109

class StaticLabel (Label) :

   110

    """

   111

        A simple literal Label, used for fixed terms in the URL

   112

    """

   113

   114

    EXPR = re.compile(r'^(?P<name>[a-zA-Z_.-]+)$')

   115

   116

    def __init__ (self, name) :

   117

        """

   118

            The given name is the literal name of this label

   119

        """

   120

   121

        self.name = name

   122

   123

    def __eq__ (self, other) :

   124

        """

   125

            Compares names

   126

        """

   127

   128

        return isinstance(other, StaticLabel) and self.name == other.name

   129

   138

    def __str__ (self) :

   139

        return self.name

   140

   141

class ValueLabel (Label) :

   142

    """

   143

        A label with a key and a value

   146

    """

   147

   148

    def __init__ (self, key, default) :

   149

        """

   150

            Set the key and default value. Default value may be None if there is no default value defined

   151

        """

   152

   153

        self.key = key

   154

        self.default = default

   155

   156

    def __eq__ (self, other) :

   157

        """

   158

            Compares keys

   159

        """

   160

   161

        return isinstance(other, ValueLabel) and self.key == other.key

   162

   163

class SimpleValueLabel (ValueLabel) :

   164

    """

   165

        A label that has a name and a simple string value

   166

    """

   167

   168

    EXPR = re.compile(r'^\{(?P<key>[a-zA-Z_][a-zA-Z0-9_]*)\}$')

   169

   170

    def __init__ (self, key, default) :

   171

        """

   172

            The given key is the name of this label's value

   173

        """

   174

   175

        super(SimpleValueLabel, self).__init__(key, default)

   176

   186

    def __str__ (self) :

   187

        if self.default :

   188

            return '{%s=%s}' % (self.key, self.default)

   189

   190

        else :

   191

            return '{%s}' % (self.key, )

   192

   193

class URL (object) :

   194

    """

   195

        Represents a specific URL

   196

    """

   197

   198

    def __init__ (self, url_mask, handler, **defaults) :

   199

        """

   200

            Create an URL with the given url mask, handler, and default values

   201

        """

   202

   203

        # store

   204

        self.url_mask = url_mask

   205

        self.handler = handler

   206

        self.defaults = defaults

   207

   208

        # build our labels

   209

        self.label_path = [Label.parse(mask, defaults) for mask in url_mask.split('/')]

   210

   211

    def get_label_path (self) :

   212

        """

   213

            Returns a list containing the labels in this url

   214

        """

   215

   216

        # copy self.label_path

   217

        return list(self.label_path)

   218

   220

        """

   222

        """

   226

   234

    def __str__ (self) :

   235

        return '/'.join(str(label) for label in self.label_path)

   236

   237

    def __repr__ (self) :

   238

        return "URL(%r, %r)" % (str(self), self.handler)

   239

   240

class URLNode (object) :

   241

    """

   242

        Represents a node in the URLTree

   243

    """

   244

   245

    def __init__ (self, parent, label) :

   246

        """

   247

            Initialize with the given parent and label, empty children dict

   248

        """

   249

   250

        # the parent URLNode

   251

        self.parent = parent

   252

   253

        # this node's Label

   254

        self.label = label

   255

   256

        # list of child URLNodes

   257

        self.children = []

   258

   259

        # this node's URL, set by add_url for an empty label_path

   260

        self.url = None

   261

   262

    def _build_child (self, label) :

   263

        """

   264

            Build, insert and return a new child Node

   265

        """

   266

   267

        # build new child

   268

        child = URLNode(self, label)

   269

   270

        # add to children

   271

        self.children.append(child)

   272

   273

        # return

   274

        return child

   275

   276

    def add_url (self, url, label_path) :

   277

        """

   278

            Add a URL object to this node under the given path. Uses recursion to process the path.

   279

   280

            The label_path argument is a (partial) label path as returned by URL.get_label_path.

   281

   282

            If label_path is empty (len zero, or begins with EmptyLabel), then the given url is assigned to this node, if no

   283

            url was assigned before.

   284

        """

   285

   286

        # matches this node?

   287

        if not label_path or isinstance(label_path[0], EmptyLabel) :

   288

            if self.url :

   289

                raise URLError(url, "node already defined")

   290

   291

            else :

   292

                # set

   293

                self.url = url

   294

   295

        else :

   296

            # pop child label from label_path

   297

            child_label = label_path.pop(0)

   298

   299

            # look for the child to recurse into

   300

            child = None

   301

   302

            # look for an existing child with that label

   303

            for child in self.children :

   304

                if child.label == child_label :

   305

                    # found, use this

   306

                    break

   307

   308

            else :

   309

                # build a new child

   310

                child = self._build_child(child_label)

   311

   312

            # recurse to handle the rest of the label_path

   313

            child.add_url(url, label_path)

   314

   316

        """

   318

   320

        """

   321

   322

        # empty label_path?

   325

            if self.url :

   326

                # this URL is the best match

   328

   329

            else :

   330

                # incomplete URL

   332

   333

        else :

   335

            label = label_path.pop(0)

   336

   339

   340

            # recurse through our children

   341

            for child in self.children :

   344

   369

   370

    def dump (self, indent=0) :

   371

        """

   372

            Returns a multi-line string representation of this Node

   373

        """

   374

   375

        return '\n'.join([

   376

            "%-45s%s" % (

   377

                ' '*indent + str(self.label) + ('/' if self.children else ''), 

   378

                (' -> %r' % self.url) if self.url else ''

   379

            )

   380

        ] + [

   381

            child.dump(indent + 4) for child in self.children

   382

        ])

   383

   384

    def __str__ (self) :

   385

        return "%s/[%s]" % (self.label, ','.join(str(child) for child in self.children))

   386

   387

class URLTree (map.Mapper) :

   388

    """

   389

        Map requests to handlers, using a defined tree of URLs

   390

    """

   391

   392

    def __init__ (self, url_list) :

   393

        """

   394

            Initialize the tree using the given list of URLs

   395

        """

   396

   397

        # root node

   398

        self.root = URLNode(None, EmptyLabel())

   399

   400

        # just add each URL

   401

        for url in url_list :

   402

            self.add_url(url)

   403

   404

    def add_url (self, url) :

   405

        """

   406

            Adds the given URL to the tree. The URL must begin with a root slash.

   407

        """

   408

        # get url's label path

   409

        path = url.get_label_path()

   410

   411

        # should begin with root

   412

        root_label = path.pop(0)

   413

        assert root_label == self.root.label, "URL must begin with root"

   414

   415

        # add to root

   416

        self.root.add_url(url, path)

   417

   418

    def match (self, url) :

   419

        """

   423

        """

   424

   425

        # normalize the URL

   426

        url = os.path.normpath(url)

   427

   428

        # split it into labels

   434

   435

        # just match starting at root

   437

   438

    def handle_request (self, request) :

   439

        """

   440

            Looks up the request's URL, and invokes its handler

   441

        """

   442

   443

        # get the request's URL path

   445

   446

        # let the URL handle it

   448

   449

# urls

   450

index           = URL(  '/',                                            handlers.index                                          )

   451

channel_view    = URL(  '/channel/{channel}',                           handlers.channel_view                                   )

   452

channel_last    = URL(  '/channel/{channel}/last/{count}/{format}',     handlers.channel_last,      count=100, format="html"    )

   453

channel_search  = URL(  '/channel/{channel}/search',                    handlers.channel_search                                 )

   454

   455

# mapper

   456

mapper = URLTree([index, channel_view, channel_last, channel_search])

   457