File: rule.py

package info (click to toggle)
python-pyscss 1.3.7-3
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, sid
  • size: 6,312 kB
  • sloc: python: 12,633; ansic: 1,545; makefile: 146; sh: 6
file content (366 lines) | stat: -rw-r--r-- 11,615 bytes parent folder | download | duplicates (3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
from __future__ import absolute_import
from __future__ import print_function
from __future__ import unicode_literals

import logging
import re

from scss.namespace import Namespace

log = logging.getLogger(__name__)

SORTED_SELECTORS = False

sort = sorted if SORTED_SELECTORS else lambda it: it


def extend_unique(seq, more):
    """Return a new sequence containing the items in `seq` plus any items in
    `more` that aren't already in `seq`, preserving the order of both.
    """
    seen = set(seq)
    new = []
    for item in more:
        if item not in seen:
            seen.add(item)
            new.append(item)

    return seq + type(seq)(new)


class SassRule(object):
    """At its heart, a CSS rule: combination of a selector and zero or more
    properties.  But this is Sass, so it also tracks some Sass-flavored
    metadata, like `@extend` rules and `@media` nesting.
    """

    def __init__(
            self, source_file, import_key=None, unparsed_contents=None,
            num_header_lines=0,
            options=None, legacy_compiler_options=None, properties=None,
            namespace=None,
            lineno=0, extends_selectors=frozenset(),
            ancestry=None,
            nested=0,
            from_source_file=None, from_lineno=0):

        self.from_source_file = from_source_file
        self.from_lineno = from_lineno

        self.source_file = source_file
        self.import_key = import_key
        self.lineno = lineno

        self.num_header_lines = num_header_lines
        self.unparsed_contents = unparsed_contents
        self.legacy_compiler_options = legacy_compiler_options or {}
        self.options = options or {}
        self.extends_selectors = extends_selectors

        if namespace is None:
            assert False
            self.namespace = Namespace()
        else:
            self.namespace = namespace

        if properties is None:
            self.properties = []
        else:
            self.properties = properties

        if ancestry is None:
            self.ancestry = RuleAncestry()
        else:
            self.ancestry = ancestry

        self.nested = nested

        self.descendants = 0

    def __repr__(self):
        # TODO probably want to encode this with string_escape on python 2, and
        # similar elsewhere, especially since this file has unicode_literals
        return "<SassRule %s, %d props>" % (
            self.ancestry,
            len(self.properties),
        )

    @property
    def selectors(self):
        # TEMPORARY
        if self.ancestry.headers and self.ancestry.headers[-1].is_selector:
            return self.ancestry.headers[-1].selectors
        else:
            return ()

    @property
    def file_and_line(self):
        """Return the filename and line number where this rule originally
        appears, in the form "foo.scss:3".  Used for error messages.
        """
        ret = "%s:%d" % (self.source_file.path, self.lineno)
        if self.from_source_file:
            ret += " (%s:%d)" % (self.from_source_file.path, self.from_lineno)
        return ret

    @property
    def is_empty(self):
        """Return whether this rule is considered "empty" -- i.e., has no
        contents that should end up in the final CSS.
        """
        if self.properties:
            # Rules containing CSS properties are never empty
            return False

        if not self.descendants:
            for header in self.ancestry.headers:
                if header.is_atrule and header.directive != '@media':
                    # At-rules should always be preserved, UNLESS they are @media
                    # blocks, which are known to be noise if they don't have any
                    # contents of their own
                    return False

        return True

    @property
    def is_pure_placeholder(self):
        selectors = self.selectors
        if not selectors:
            return False
        for s in selectors:
            if not s.has_placeholder:
                return False
        return True


    def copy(self):
        return type(self)(
            source_file=self.source_file,
            lineno=self.lineno,

            from_source_file=self.from_source_file,
            from_lineno=self.from_lineno,

            unparsed_contents=self.unparsed_contents,

            legacy_compiler_options=self.legacy_compiler_options,
            options=self.options,
            #properties=list(self.properties),
            properties=self.properties,
            extends_selectors=self.extends_selectors,
            #ancestry=list(self.ancestry),
            ancestry=self.ancestry,

            namespace=self.namespace.derive(),
            nested=self.nested,
        )


class RuleAncestry(object):
    def __init__(self, headers=()):
        self.headers = tuple(headers)

    def __repr__(self):
        return "<%s %r>" % (type(self).__name__, self.headers)

    def __len__(self):
        return len(self.headers)

    def with_nested_selectors(self, c_selectors):
        if self.headers and self.headers[-1].is_selector:
            # Need to merge with parent selectors
            p_selectors = self.headers[-1].selectors

            new_selectors = []
            for p_selector in p_selectors:
                for c_selector in c_selectors:
                    new_selectors.append(c_selector.with_parent(p_selector))

            # Replace the last header with the new merged selectors
            new_headers = self.headers[:-1] + (BlockSelectorHeader(new_selectors),)
            return RuleAncestry(new_headers)

        else:
            # Whoops, no parent selectors.  Just need to double-check that
            # there are no uses of `&`.
            for c_selector in c_selectors:
                if c_selector.has_parent_reference:
                    raise ValueError("Can't use parent selector '&' in top-level rules")

            # Add the children as a new header
            new_headers = self.headers + (BlockSelectorHeader(c_selectors),)
            return RuleAncestry(new_headers)

    def with_more_selectors(self, selectors):
        """Return a new ancestry that also matches the given selectors.  No
        nesting is done.
        """
        if self.headers and self.headers[-1].is_selector:
            new_selectors = extend_unique(
                self.headers[-1].selectors,
                selectors)
            new_headers = self.headers[:-1] + (
                BlockSelectorHeader(new_selectors),)
            return RuleAncestry(new_headers)
        else:
            new_headers = self.headers + (BlockSelectorHeader(selectors),)
            return RuleAncestry(new_headers)


class BlockHeader(object):
    """..."""
    # TODO doc me depending on how UnparsedBlock is handled...

    is_atrule = False
    is_scope = False
    is_selector = False

    @classmethod
    def parse(cls, prop, has_contents=False):
        num_lines = prop.count('\n')
        prop = prop.strip()

        # Simple pre-processing
        if prop.startswith('+') and not has_contents:
            # Expand '+' at the beginning of a rule as @include.  But not if
            # there's a block, because that's probably a CSS selector.
            # DEVIATION: this is some semi hybrid of Sass and xCSS syntax
            prop = '@include ' + prop[1:]
            try:
                if '(' not in prop or prop.index(':') < prop.index('('):
                    prop = prop.replace(':', '(', 1)
                    if '(' in prop:
                        prop += ')'
            except ValueError:
                pass
        elif prop.startswith('='):
            # Expand '=' at the beginning of a rule as @mixin
            prop = '@mixin ' + prop[1:]
        elif prop.startswith('@prototype '):
            # Remove '@prototype '
            # TODO what is @prototype??
            prop = prop[11:]

        # Minor parsing
        if prop.startswith('@'):
            # This pattern MUST NOT BE ABLE TO FAIL!
            # This is slightly more lax than the CSS syntax technically allows,
            # e.g. identifiers aren't supposed to begin with three hyphens.
            # But we don't care, and will just spit it back out anyway.
            m = re.match(
                '@(else if|[-_a-zA-Z0-9\U00000080-\U0010FFFF]*)\\b',
                prop, re.I)
            directive = m.group(0).lower()
            argument = prop[len(directive):].strip()
            if not argument:
                argument = None
            return BlockAtRuleHeader(directive, argument, num_lines)
        elif prop.split(None, 1)[0].endswith(':'):
            # Syntax is "<scope>: [prop]" -- if the optional prop exists, it
            # becomes the first rule with no suffix
            scope, unscoped_value = prop.split(':', 1)
            scope = scope.rstrip()
            unscoped_value = unscoped_value.lstrip()
            return BlockScopeHeader(scope, unscoped_value, num_lines)
        else:
            return BlockSelectorHeader(prop, num_lines)


class BlockAtRuleHeader(BlockHeader):
    is_atrule = True

    def __init__(self, directive, argument, num_lines=0):
        self.directive = directive
        self.argument = argument

        self.num_lines = num_lines

    def __repr__(self):
        return "<%s %r %r>" % (type(self).__name__, self.directive, self.argument)

    def render(self):
        if self.argument:
            return "%s %s" % (self.directive, self.argument)
        else:
            return self.directive


class BlockSelectorHeader(BlockHeader):
    is_selector = True

    def __init__(self, selectors, num_lines=0):
        self.selectors = tuple(selectors)

        self.num_lines = num_lines

    def __repr__(self):
        return "<%s %r>" % (type(self).__name__, self.selectors)

    def render(self, sep=', ', super_selector=''):
        return sep.join(sort(
            super_selector + s.render()
            for s in self.selectors
            if not s.has_placeholder))


class BlockScopeHeader(BlockHeader):
    is_scope = True

    def __init__(self, scope, unscoped_value, num_lines=0):
        self.scope = scope

        if unscoped_value:
            self.unscoped_value = unscoped_value
        else:
            self.unscoped_value = None

        self.num_lines = num_lines


class UnparsedBlock(object):
    """A Sass block whose contents have not yet been parsed.

    At the top level, CSS (and Sass) documents consist of a sequence of blocks.
    A block may be a ruleset:

        selector { block; block; block... }

    Or it may be an @-rule:

        @rule arguments { block; block; block... }

    Or it may be only a single property declaration:

        property: value

    pyScss's first parsing pass breaks the document into these blocks, and each
    block becomes an instance of this class.
    """

    def __init__(self, parent_rule, lineno, prop, unparsed_contents):
        self.parent_rule = parent_rule
        self.header = BlockHeader.parse(prop, has_contents=bool(unparsed_contents))

        # Basic properties
        self.lineno = (
            parent_rule.lineno - parent_rule.num_header_lines + lineno - 1)
        self.prop = prop
        self.unparsed_contents = unparsed_contents

    @property
    def directive(self):
        return self.header.directive

    @property
    def argument(self):
        return self.header.argument

    ### What kind of thing is this?

    @property
    def is_atrule(self):
        return self.header.is_atrule

    @property
    def is_scope(self):
        return self.header.is_scope