~doctormo/+junk/css-parser

« back to all changes in this revision

Viewing changes to csslavie/base.py

  • Committer: Martin Owens
  • Date: 2014-07-13 21:48:23 UTC
  • Revision ID: doctormo@gmail.com-20140713214823-774n9vbbhw93zlbh
Move the files around and add some simple events

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
#
 
2
# Copyright 2012-2014 Martin Owens <doctormo@gmail.com>
 
3
# Copyright      2014 Ian Denhardt <ian@zenhack.net>
 
4
#
 
5
# This program is free software: you can redistribute it and/or modify
 
6
#  it under the terms of the GNU General Public License as published by
 
7
#  the Free Software Foundation, either version 3 of the License, or
 
8
#  (at your option) any later version.
 
9
#
 
10
#  This program is distributed in the hope that it will be useful,
 
11
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
#  GNU General Public License for more details.
 
14
#
 
15
#  You should have received a copy of the GNU General Public License
 
16
#  along with this program.  If not, see <http://www.gnu.org/licenses/>
 
17
#
 
18
"""
 
19
"""
 
20
 
 
21
 
 
22
from collections import OrderedDict, Callable
 
23
 
 
24
 
 
25
class DefaultOrderedDict(OrderedDict):
 
26
    """Copied from: http://stackoverflow.com/questions/6190331/can-i-do-an-ordered-default-dict-in-python"""
 
27
    def __init__(self, default_factory=None, *a, **kw):
 
28
        if (default_factory is not None and
 
29
            not isinstance(default_factory, Callable)):
 
30
            raise TypeError('first argument must be callable')
 
31
        OrderedDict.__init__(self, *a, **kw)
 
32
        self.default_factory = default_factory
 
33
 
 
34
    def __getitem__(self, key):
 
35
        try:
 
36
            return OrderedDict.__getitem__(self, key)
 
37
        except KeyError:
 
38
            return self.__missing__(key)
 
39
 
 
40
    def __missing__(self, key):
 
41
        if self.default_factory is None:
 
42
            raise KeyError(key)
 
43
        self[key] = value = self.default_factory()
 
44
        return value
 
45
 
 
46
    def __reduce__(self):
 
47
        if self.default_factory is None:
 
48
            args = tuple()
 
49
        else:
 
50
            args = self.default_factory,
 
51
        return type(self), args, None, None, self.items()
 
52
 
 
53
    def copy(self):
 
54
        return self.__copy__()
 
55
 
 
56
    def __copy__(self):
 
57
        return type(self)(self.default_factory, self)
 
58
 
 
59
    def __deepcopy__(self, memo):
 
60
        import copy
 
61
        return type(self)(self.default_factory,
 
62
                          copy.deepcopy(self.items()))
 
63
    def __repr__(self):
 
64
        return 'OrderedDefaultDict(%s, %s)' % (self.default_factory,
 
65
                                        OrderedDict.__repr__(self))
 
66
 
 
67
    def sort_to_end(self, name):
 
68
        if name in self:
 
69
            self[name] = self.pop(name)
 
70
 
 
71
    def super_keys(self):
 
72
        ret = set()
 
73
        for v in self.values():
 
74
            ret.update(v.keys())
 
75
        return ret
 
76
 
 
77
    def super_gets(self, keys):
 
78
        for key in keys:
 
79
            yield (key, self.super_get(key))
 
80
 
 
81
    def super_get(self, key):
 
82
        for d in reversed(self):
 
83
            if key in self[d]:
 
84
                return self[d][key]
 
85
        return None
 
86
 
 
87
 
 
88
class Event(set):
 
89
    def handle(self, handler):
 
90
        self.add(handler)
 
91
        return self
 
92
 
 
93
    def unhandle(self, handler):
 
94
        try:
 
95
            self.remove(handler)
 
96
        except:
 
97
            raise ValueError("Handler is not handling this event, so cannot unhandle it.")
 
98
        return self
 
99
 
 
100
    def fire(self, *args, **kargs):
 
101
        for handler in self:
 
102
            handler(*args, **kargs)
 
103
 
 
104
    __iadd__ = handle
 
105
    __isub__ = unhandle
 
106
    __call__ = fire
 
107
 
 
108
 
 
109