1

     2

"""

     3

    URL mapping for the irclogs.qmsk.net site

     4

"""

     5

     6

import re

     7

import os.path

     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

    22

class LabelValue (object) :

    23

    """

    24

        Represents the value of a ValueLabel...

    25

    """

    26

    27

    def __init__ (self, label, value) :

    28

        """

    29

            Just store

    30

        """

    31

    32

        self.label = label

    33

        self.value = value

    34

    35

    def __str__ (self) :

    36

        return "%s=%s" % (self.label.key, self.value)

    37

    38

    def __repr__ (self) :

    39

        return "<%s>" % self

    40

    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, ))

    77

    79

        """

    80

            Match this label against the given value, returning either True to match without a value, a LabelValue

    85

        """

    86

    87

        abstract

    88

    89

class EmptyLabel (Label) :

    90

    """

    91

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

    92

    """

    93

    94

    def __eq__ (self, other) :

    95

        """

    96

            Just compares type

    97

        """

    98

    99

        return isinstance(other, EmptyLabel)

   100

   102

        """

   103

            Match empty string -> True

   104

        """

   111

        if value == '' :

   112

            return True

   113

   114

    def __str__ (self) :

   115

        return ''

   116

   117

class StaticLabel (Label) :

   118

    """

   119

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

   120

    """

   121

   122

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

   123

   124

    def __init__ (self, name) :

   125

        """

   126

            The given name is the literal name of this label

   127

        """

   128

   129

        self.name = name

   130

   131

    def __eq__ (self, other) :

   132

        """

   133

            Compares names

   134

        """

   135

   136

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

   137

   139

        """

   140

            Match exactly -> True

   141

        """

   142

   148

        if value == self.name :

   149

            return True

   150

   151

    def __str__ (self) :

   152

        return self.name

   153

   154

class ValueLabel (Label) :

   155

    """

   156

        A label with a key and a value

   157

   158

        XXX: do we even need this?

   159

    """

   160

   161

    def __init__ (self, key, default) :

   162

        """

   163

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

   164

        """

   165

   166

        self.key = key

   167

        self.default = default

   168

   169

    def __eq__ (self, other) :

   170

        """

   171

            Compares keys

   172

        """

   173

   174

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

   175

   176

class SimpleValueLabel (ValueLabel) :

   177

    """

   178

        A label that has a name and a simple string value

   179

    """

   180

   181

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

   182

   183

    def __init__ (self, key, default) :

   184

        """

   185

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

   186

        """

   187

   188

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

   189

   191

        """

   192

            Match -> LabelValue

   193

        """

   202

   203

    def __str__ (self) :

   204

        if self.default :

   205

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

   206

   207

        else :

   208

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

   209

   210

class URL (object) :

   211

    """

   212

        Represents a specific URL

   213

    """

   214

   215

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

   216

        """

   217

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

   218

        """

   219

   220

        # store

   221

        self.url_mask = url_mask

   222

        self.handler = handler

   223

        self.defaults = defaults

   224

   225

        # build our labels

   226

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

   227

   228

    def get_label_path (self) :

   229

        """

   230

            Returns a list containing the labels in this url

   231

        """

   232

   233

        # copy self.label_path

   234

        return list(self.label_path)

   235

   236

    def execute (self, request, label_values) :

   237

        """

   238

            Invoke the handler, using the given label values

   239

        """

   240

   241

        # start with the defaults

   242

        kwargs = self.defaults()

   243

   244

        # then add all the values

   245

        for label_value in label_values :

   246

            kwargs[label_value.label.key] = label_value.value

   247

   248

        # execute the handler

   249

        return self.handler(request, **kwargs)

   250

   251

    def __str__ (self) :

   252

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

   253

   254

    def __repr__ (self) :

   255

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

   256

   257

class URLNode (object) :

   258

    """

   259

        Represents a node in the URLTree

   260

    """

   261

   262

    def __init__ (self, parent, label) :

   263

        """

   264

            Initialize with the given parent and label, empty children dict

   265

        """

   266

   267

        # the parent URLNode

   268

        self.parent = parent

   269

   270

        # this node's Label

   271

        self.label = label

   272

   273

        # list of child URLNodes

   274

        self.children = []

   275

   276

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

   277

        self.url = None

   278

   279

    def _build_child (self, label) :

   280

        """

   281

            Build, insert and return a new child Node

   282

        """

   283

   284

        # build new child

   285

        child = URLNode(self, label)

   286

   287

        # add to children

   288

        self.children.append(child)

   289

   290

        # return

   291

        return child

   292

   293

    def add_url (self, url, label_path) :

   294

        """

   295

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

   296

   297

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

   298

   299

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

   300

            url was assigned before.

   301

        """

   302

   303

        # matches this node?

   304

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

   305

            if self.url :

   306

                raise URLError(url, "node already defined")

   307

   308

            else :

   309

                # set

   310

                self.url = url

   311

   312

        else :

   313

            # pop child label from label_path

   314

            child_label = label_path.pop(0)

   315

   316

            # look for the child to recurse into

   317

            child = None

   318

   319

            # look for an existing child with that label

   320

            for child in self.children :

   321

                if child.label == child_label :

   322

                    # found, use this

   323

                    break

   324

   325

            else :

   326

                # build a new child

   327

                child = self._build_child(child_label)

   328

   329

            # recurse to handle the rest of the label_path

   330

            child.add_url(url, label_path)

   331

   332

    def match (self, label_path) :

   333

        """

   334

            Locate the URL object corresponding to the given label_path value under this node.

   335

   336

            Returns a (url, label_values) tuple

   337

        """

   338

   339

        # empty label_path?

   340

        if not label_path or label_path[0] == '' :

   341

            # the search ends at this node

   342

            if self.url :

   343

                # this URL is the best match

   344

                return (self.url, [])

   345

   352

            else :

   353

                # incomplete URL

   354

                raise URLError("no URL handler defined for this Node")

   355

   356

        else :

   357

            # pop the next label from the label path

   358

            label = label_path.pop(0)

   359

   360

            # return one match...

   361

            match = value = None

   362

   363

            # recurse through our children

   364

            for child in self.children :

   365

                # match value

   366

                value = child.label.match(label)

   367

   368

                # skip those that don't match at all

   369

                if not value :

   370

                    continue;

   371

   372

                # already found a match? :/

   373

                if match :

   374

                    raise URLError("Ambiguous URL")

   375

   376

                # ok, but continue looking to make sure there's no ambiguous URLs

   377

                match = child

   378

   379

            # found something?

   380

            if not match :

   381

                raise URLError("No child found for label")

   382

   383

            # ok, recurse into the match

   384

            url, label_value = match.match(label_path)

   385

   386

            # add our value?

   387

            if isinstance(value, LabelValue) :

   388

                label_value.append(value)

   389

   390

            # return the match

   391

            return url, label_value

   392

   393

    def dump (self, indent=0) :

   394

        """

   395

            Returns a multi-line string representation of this Node

   396

        """

   397

   398

        return '\n'.join([

   399

            "%-45s%s" % (

   400

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

   401

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

   402

            )

   403

        ] + [

   404

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

   405

        ])

   406

   407

    def __str__ (self) :

   408

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

   409

   410

class URLTree (map.Mapper) :

   411

    """

   412

        Map requests to handlers, using a defined tree of URLs

   413

    """

   414

   415

    def __init__ (self, url_list) :

   416

        """

   417

            Initialize the tree using the given list of URLs

   418

        """

   419

   420

        # root node

   421

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

   422

   423

        # just add each URL

   424

        for url in url_list :

   425

            self.add_url(url)

   426

   427

    def add_url (self, url) :

   428

        """

   429

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

   430

        """

   431

        # get url's label path

   432

        path = url.get_label_path()

   433

   434

        # should begin with root

   435

        root_label = path.pop(0)

   436

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

   437

   438

        # add to root

   439

        self.root.add_url(url, path)

   440

   441

    def match (self, url) :

   442

        """

   443

            Find the URL object best corresponding to the given url, matching any ValueLabels.

   444

   445

            Returns an (URL, [LabelValue]) tuple.

   446

        """

   447

   448

        # normalize the URL

   449

        url = os.path.normpath(url)

   450

   451

        # split it into labels

   452

        path = url.split('/')

   453

   454

        # ensure that it starts with a /

   455

        root_label = path.pop(0)

   456

        assert self.root.label.match(root_label), "URL must begin with root"

   457

   458

        # just match starting at root

   459

        return self.root.match(path)

   460

   461

    def handle_request (self, request) :

   462

        """

   463

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

   464

        """

   465

   466

        # get the request's URL path

   467

        url, label_values = self.match(request.get_page_name())

   468

   469

        # let the URL handle it

   470

        url.execute(request, label_values)

   471

   472

# urls

   473

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

   474

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

   475

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

   476

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

   477

   478

# mapper

   479

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

   480