1

"""

     2

    Tree-based URL mapping

     3

"""

     4

     5

import re

     6

import os.path

     7

     8

from qmsk.web import map

     9

    10

class URLError (Exception) :

    11

    """

    12

        Error with an URL definition

    13

    """

    14

    15

    pass

    16

    17

class LabelValue (object) :

    18

    """

    19

        Represents the value of a ValueLabel... love these names

    20

    """

    21

    22

    def __init__ (self, label, value) :

    23

        """

    24

            Just store

    25

        """

    26

    27

        self.label = label

    28

        self.value = value

    29

    30

    def __str__ (self) :

    31

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

    32

    33

    def __repr__ (self) :

    34

        return "<%s>" % self

    35

    36

class Label (object) :

    37

    """

    38

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

    39

    """

    40

    41

    @staticmethod

    43

        """

    45

        """

    46

    47

        # empty?

    48

        if not mask :

    49

            return EmptyLabel()

    50

    51

        # simple value?

    52

        match = SimpleValueLabel.EXPR.match(mask)

    53

    54

        if match :

    55

            # key

    56

            key = match.group('key')

    57

    58

            # type

    59

            type = match.group("type")

    60

    63

    64

            # defaults?

    65

            default = defaults.get(key)

    66

    67

            if not default :

    68

                default = match.group('default')

    69

    70

                if default :

    71

                    # apply type to default

    73

    74

            # build

    75

            return SimpleValueLabel(key, type, default)

    76

    77

        # static?

    78

        match = StaticLabel.EXPR.match(mask)

    79

    80

        if match :

    81

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

    82

    83

        # invalid

    84

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

    85

    86

    def match (self, value=None) :

    87

        """

    88

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

    89

            object, or boolean false to not match.

    90

    91

            If value is None, this means that only a default value should be returned.

    92

        """

    93

    94

        abstract

    95

    96

    def build (self, value_dict) :

    97

        """

    98

            Return a string representing this label, using the values in the given value_dict if needed

    99

        """

   100

   101

        abstract

   102

   103

class EmptyLabel (Label) :

   104

    """

   105

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

   106

    """

   107

   108

    def __eq__ (self, other) :

   109

        """

   110

            Just compares type

   111

        """

   112

   113

        return isinstance(other, EmptyLabel)

   114

   115

    def match (self, value=None) :

   116

        """

   117

            Match empty string -> True

   118

        """

   119

   120

        # no default

   121

        if value is None :

   122

            return False

   123

   124

        # only empty segments

   125

        if value == '' :

   126

            return True

   127

   128

    def build (self, values) :

   129

        return str(self)

   130

   131

    def __str__ (self) :

   132

        return ''

   133

   134

class StaticLabel (Label) :

   135

    """

   136

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

   137

    """

   138

   139

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

   140

   141

    def __init__ (self, name) :

   142

        """

   143

            The given name is the literal name of this label

   144

        """

   145

   146

        self.name = name

   147

   148

    def __eq__ (self, other) :

   149

        """

   150

            Compares names

   151

        """

   152

   153

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

   154

   155

    def match (self, value=None) :

   156

        """

   157

            Match exactly -> True

   158

        """

   159

   160

        # no defaults

   161

        if value is None :

   162

            return False

   163

   164

        # match name

   165

        if value == self.name :

   166

            return True

   167

   168

    def build (self, values) :

   169

        return str(self)

   170

   171

    def __str__ (self) :

   172

        return self.name

   173

   174

class ValueLabel (Label) :

   175

    """

   176

        A label with a key and a value

   177

   178

        XXX: do we even need this?

   179

    """

   180

   181

    def __init__ (self, key, default) :

   182

        """

   183

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

   184

        """

   185

   186

        self.key = key

   187

        self.default = default

   188

   189

    def __eq__ (self, other) :

   190

        """

   191

            Compares keys

   192

        """

   193

   194

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

   195

   196

    def build (self, values) :

   197

        """

   198

            Return either the assigned value from values, our default value, or raise an error

   199

        """

   200

   201

        value = values.get(self.key)

   202

   203

        if not value and self.default :

   204

            value = self.default

   205

   206

        elif not value :

   207

            raise URLError("No value given for label %r" % (self.key, ))

   208

   209

        return value

   210

   211

class SimpleValueLabel (ValueLabel) :

   212

    """

   213

        A label that has a name and a simple string value

   214

    """

   215

   216

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

   217

   219

        """

   220

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

   221

        """

   222

   223

        # type

   224

        self.type = type

   225

   226

        # store

   227

        self.key = key

   228

        self.default = default

   229

   230

    def match (self, value=None) :

   231

        """

   232

            Match -> LabelValue

   233

        """

   234

   235

        # default?

   236

        if value is None and self.default :

   237

            return LabelValue(self, self.default)

   238

   239

        # only non-empty values!

   240

        elif value :

   245

            # convert with type

   247

   248

            return LabelValue(self, value)

   249

   250

    def __str__ (self) :

   251

        return '{%s%s%s}' % (

   252

            self.key, 

   254

            '=%s' % (self.default, ) if self.default else '',

   255

        )

   256

   380

class URLConfig (object) :

   381

    """

   385

    """

   386

   387

    # built-in type codes

   388

    BUILTIN_TYPES = {

   389

        # string

   391

   392

        # integer

   394

    }

   395

   401

        """

   402

            Create an URLConfig for use with URL

   403

   405

            type specifications in addition to the defaults.

   406

        """

   407

   408

        # build our type_dict

   409

        self.type_dict = self.BUILTIN_TYPES.copy()

   410

   411

        # apply the given type_dict

   412

        if type_dict :

   418

            self.type_dict.update(type_dict)

   419

   457

class URL (object) :

   458

    """

   459

        Represents a specific URL

   460

    """

   461

   462

   464

        """

   465

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

   466

        """

   467

   468

        # store

   469

        self.config = config

   470

        self.url_mask = url_mask

   471

        self.handler = handler

   472

        self.defaults = defaults

   473

   474

        # query string

   475

        self.query_args = dict()

   476

   477

        # parse any query string

   478

        # XXX: conflicts with regexp syntax

   479

        if '/?' in url_mask :

   480

            url_mask, query_mask = url_mask.split('/?')

   481

   482

        else :

   483

            query_mask = None

   484

   485

        # build our label path

   487

   488

        # build our query args list

   489

        if query_mask :

   490

            # split into items

   491

            for query_item in query_mask.split('&') :

   492

                # parse default

   493

                if '=' in query_item :

   494

                    query_item, default = query_item.split('=')

   495

   496

                else :

   497

                    default = None

   498

   499

                # parse type

   500

                if ':' in query_item :

   501

                    query_item, type = query_item.split(':')

   502

                else :

   503

                    type = None

   504

   505

                # parse key

   506

                key = query_item

   507