csslib.php 14.4 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**
18
 * This file contains CSS file serving functions.
19
 *
20
21
 * NOTE: these functions are not expected to be used from any addons.
 *
22
 * @package core
23
 * @copyright 2012 Sam Hemelryk
24
 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
25
26
 */

27
defined('MOODLE_INTERNAL') || die();
28

29
30
31
32
33
34
if (!defined('THEME_DESIGNER_CACHE_LIFETIME')) {
    // This can be also set in config.php file,
    // it needs to be higher than the time it takes to generate all CSS content.
    define('THEME_DESIGNER_CACHE_LIFETIME', 10);
}

35
36
37
/**
 * Stores CSS in a file at the given path.
 *
38
39
 * This function either succeeds or throws an exception.
 *
40
41
 * @param theme_config $theme The theme that the CSS belongs to.
 * @param string $csspath The path to store the CSS at.
42
 * @param string $csscontent the complete CSS in one string
43
44
45
46
 * @param bool $chunk If set to true these files will be chunked to ensure
 *      that no one file contains more than 4095 selectors.
 * @param string $chunkurl If the CSS is be chunked then we need to know the URL
 *      to use for the chunked files.
47
 */
48
function css_store_css(theme_config $theme, $csspath, $csscontent, $chunk = false, $chunkurl = null) {
49
50
    global $CFG;

51
52
53
54
55
56
57
58
    clearstatcache();
    if (!file_exists(dirname($csspath))) {
        @mkdir(dirname($csspath), $CFG->directorypermissions, true);
    }

    // Prevent serving of incomplete file from concurrent request,
    // the rename() should be more atomic than fwrite().
    ignore_user_abort(true);
59

60
    // First up write out the single file for all those using decent browsers.
61
    css_write_file($csspath, $csscontent);
62
63
64

    if ($chunk) {
        // If we need to chunk the CSS for browsers that are sub-par.
65
        $css = css_chunk_by_selector_count($csscontent, $chunkurl);
66
67
68
69
70
71
72
73
74
75
        $files = count($css);
        $count = 1;
        foreach ($css as $content) {
            if ($count === $files) {
                // If there is more than one file and this IS the last file.
                $filename = preg_replace('#\.css$#', '.0.css', $csspath);
            } else {
                // If there is more than one file and this is not the last file.
                $filename = preg_replace('#\.css$#', '.'.$count.'.css', $csspath);
            }
76
            $count++;
77
            css_write_file($filename, $content);
78
        }
79
    }
80

81
82
83
84
    ignore_user_abort(false);
    if (connection_aborted()) {
        die;
    }
85
86
}

87
88
89
90
91
92
93
94
95
96
97
98
99
/**
 * Writes a CSS file.
 *
 * @param string $filename
 * @param string $content
 */
function css_write_file($filename, $content) {
    global $CFG;
    if ($fp = fopen($filename.'.tmp', 'xb')) {
        fwrite($fp, $content);
        fclose($fp);
        rename($filename.'.tmp', $filename);
        @chmod($filename, $CFG->filepermissions);
100
        @unlink($filename.'.tmp'); // Just in case anything fails.
101
102
103
    }
}

104
105
106
/**
 * Takes CSS and chunks it if the number of selectors within it exceeds $maxselectors.
 *
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 * The chunking will not split a group of selectors, or a media query. That means that
 * if n > $maxselectors and there are n selectors grouped together,
 * they will not be chunked and you could end up with more selectors than desired.
 * The same applies for a media query that has more than n selectors.
 *
 * Also, as we do not split group of selectors or media queries, the chunking might
 * not be as optimal as it could be, having files with less selectors than it could
 * potentially contain.
 *
 * String functions used here are not compliant with unicode characters. But that is
 * not an issue as the syntax of CSS is using ASCII codes. Even if we have unicode
 * characters in comments, or in the property 'content: ""', it will behave correcly.
 *
 * Please note that this strips out the comments if chunking happens.
 *
122
123
124
 * @param string $css The CSS to chunk.
 * @param string $importurl The URL to use for import statements.
 * @param int $maxselectors The number of selectors to limit a chunk to.
125
 * @param int $buffer Not used any more.
126
127
128
 * @return array An array of CSS chunks.
 */
function css_chunk_by_selector_count($css, $importurl, $maxselectors = 4095, $buffer = 50) {
129

130
131
132
133
134
135
136
    // Check if we need to chunk this CSS file.
    $count = substr_count($css, ',') + substr_count($css, '{');
    if ($count < $maxselectors) {
        // The number of selectors is less then the max - we're fine.
        return array($css);
    }

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
    $chunks = array();                  // The final chunks.
    $offsets = array();                 // The indexes to chunk at.
    $offset = 0;                        // The current offset.
    $selectorcount = 0;                 // The number of selectors since the last split.
    $lastvalidoffset = 0;               // The last valid index to split at.
    $lastvalidoffsetselectorcount = 0;  // The number of selectors used at the time were could split.
    $inrule = 0;                        // The number of rules we are in, should not be greater than 1.
    $inmedia = false;                   // Whether or not we are in a media query.
    $mediacoming = false;               // Whether or not we are expeting a media query.
    $currentoffseterror = null;         // Not null when we have recorded an error for the current split.
    $offseterrors = array();            // The offsets where we found errors.

    // Remove the comments. Because it's easier, safer and probably a lot of other good reasons.
    $css = preg_replace('#/\*(.*?)\*/#s', '', $css);
    $strlen = strlen($css);

    // Walk through the CSS content character by character.
    for ($i = 1; $i <= $strlen; $i++) {
        $char = $css[$i - 1];
        $offset = $i;

        // Is that a media query that I see coming towards us?
        if ($char === '@') {
            if (!$inmedia && substr($css, $offset, 5) === 'media') {
                $mediacoming = true;
            }
        }

        // So we are entering a rule or a media query...
        if ($char === '{') {
            if ($mediacoming) {
                $inmedia = true;
                $mediacoming = false;
            } else {
                $inrule++;
                $selectorcount++;
            }
        }

176
177
178
        // Let's count the number of selectors, but only if we are not in a rule, or in
        // the definition of a media query, as they can contain commas too.
        if (!$mediacoming && !$inrule && $char === ',') {
179
180
181
182
183
184
185
186
187
188
189
190
191
            $selectorcount++;
        }

        // We reached the end of something.
        if ($char === '}') {
            // Oh, we are in a media query.
            if ($inmedia) {
                if (!$inrule) {
                    // This is the end of the media query.
                    $inmedia = false;
                } else {
                    // We were in a rule, in the media query.
                    $inrule--;
192
                }
193
194
            } else {
                $inrule--;
195
196
197
198
199
200
                // Handle stupid broken CSS where there are too many } brackets,
                // as this can cause it to break (with chunking) where it would
                // coincidentally have worked otherwise.
                if ($inrule < 0) {
                    $inrule = 0;
                }
201
202
203
204
205
206
            }

            // We are not in a media query, and there is no pending rule, it is safe to split here.
            if (!$inmedia && !$inrule) {
                $lastvalidoffset = $offset;
                $lastvalidoffsetselectorcount = $selectorcount;
207
            }
208
209
210
211
212
213
214
215
216
217
218
219
220
        }

        // Alright, this is splitting time...
        if ($selectorcount > $maxselectors) {
            if (!$lastvalidoffset) {
                // We must have reached more selectors into one set than we were allowed. That means that either
                // the chunk size value is too small, or that we have a gigantic group of selectors, or that a media
                // query contains more selectors than the chunk size. We have to ignore this because we do not
                // support split inside a group of selectors or media query.
                if ($currentoffseterror === null) {
                    $currentoffseterror = $offset;
                    $offseterrors[] = $currentoffseterror;
                }
221
            } else {
222
223
224
225
226
                // We identify the offset to split at and reset the number of selectors found from there.
                $offsets[] = $lastvalidoffset;
                $selectorcount = $selectorcount - $lastvalidoffsetselectorcount;
                $lastvalidoffset = 0;
                $currentoffseterror = null;
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

    // Report offset errors.
    if (!empty($offseterrors)) {
        debugging('Could not find a safe place to split at offset(s): ' . implode(', ', $offseterrors) . '. Those were ignored.',
            DEBUG_DEVELOPER);
    }

    // Now that we have got the offets, we can chunk the CSS.
    $offsetcount = count($offsets);
    foreach ($offsets as $key => $index) {
        $start = 0;
        if ($key > 0) {
            $start = $offsets[$key - 1];
        }
        // From somewhere up to the offset.
        $chunks[] = substr($css, $start, $index - $start);
    }
    // Add the last chunk (if there is one), from the last offset to the end of the string.
    if (end($offsets) != $strlen) {
        $chunks[] = substr($css, end($offsets));
    }

    // The array $chunks now contains CSS split into perfect sized chunks.
253
254
255
256
257
258
259
260
261
262
    // Import statements can only appear at the very top of a CSS file.
    // Imported sheets are applied in the the order they are imported and
    // are followed by the contents of the CSS.
    // This is terrible for performance.
    // It means we must put the import statements at the top of the last chunk
    // to ensure that things are always applied in the correct order.
    // This way the chunked files are included in the order they were chunked
    // followed by the contents of the final chunk in the actual sheet.
    $importcss = '';
    $slashargs = strpos($importurl, '.php?') === false;
263
    $parts = count($chunks);
264
    for ($i = 1; $i < $parts; $i++) {
265
266
267
268
269
270
        if ($slashargs) {
            $importcss .= "@import url({$importurl}/chunk{$i});\n";
        } else {
            $importcss .= "@import url({$importurl}&chunk={$i});\n";
        }
    }
271
272
    $importcss .= end($chunks);
    $chunks[key($chunks)] = $importcss;
273

274
    return $chunks;
275
276
}

277
278
279
/**
 * Sends a cached CSS file
 *
280
 * This function sends the cached CSS file. Remember it is generated on the first
281
282
283
 * request, then optimised/minified, and finally cached for serving.
 *
 * @param string $csspath The path to the CSS file we want to serve.
284
 * @param string $etag The revision to make sure we utilise any caches.
285
 */
286
function css_send_cached_css($csspath, $etag) {
287
288
    // 60 days only - the revision may get incremented quite often.
    $lifetime = 60*60*24*60;
289

290
    header('Etag: "'.$etag.'"');
291
292
293
294
    header('Content-Disposition: inline; filename="styles.php"');
    header('Last-Modified: '. gmdate('D, d M Y H:i:s', filemtime($csspath)) .' GMT');
    header('Expires: '. gmdate('D, d M Y H:i:s', time() + $lifetime) .' GMT');
    header('Pragma: ');
295
    header('Cache-Control: public, max-age='.$lifetime);
296
297
298
299
300
301
302
303
304
305
    header('Accept-Ranges: none');
    header('Content-Type: text/css; charset=utf-8');
    if (!min_enable_zlib_compression()) {
        header('Content-Length: '.filesize($csspath));
    }

    readfile($csspath);
    die;
}

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
/**
 * Sends a cached CSS content
 *
 * @param string $csscontent The actual CSS markup.
 * @param string $etag The revision to make sure we utilise any caches.
 */
function css_send_cached_css_content($csscontent, $etag) {
    // 60 days only - the revision may get incremented quite often.
    $lifetime = 60*60*24*60;

    header('Etag: "'.$etag.'"');
    header('Content-Disposition: inline; filename="styles.php"');
    header('Last-Modified: '. gmdate('D, d M Y H:i:s', time()) .' GMT');
    header('Expires: '. gmdate('D, d M Y H:i:s', time() + $lifetime) .' GMT');
    header('Pragma: ');
    header('Cache-Control: public, max-age='.$lifetime);
    header('Accept-Ranges: none');
    header('Content-Type: text/css; charset=utf-8');
    if (!min_enable_zlib_compression()) {
        header('Content-Length: '.strlen($csscontent));
    }

    echo($csscontent);
    die;
}

332
333
334
/**
 * Sends CSS directly without caching it.
 *
335
336
 * This function takes a raw CSS string, optimises it if required, and then
 * serves it.
337
 * Turning both themedesignermode and CSS optimiser on at the same time is awful
338
339
340
341
 * for performance because of the optimiser running here. However it was done so
 * that theme designers could utilise the optimised output during development to
 * help them optimise their CSS... not that they should write lazy CSS.
 *
342
 * @param string $css
343
 */
344
function css_send_uncached_css($css) {
345
346
347
348
349
350
351
352
353
354
    header('Content-Disposition: inline; filename="styles_debug.php"');
    header('Last-Modified: '. gmdate('D, d M Y H:i:s', time()) .' GMT');
    header('Expires: '. gmdate('D, d M Y H:i:s', time() + THEME_DESIGNER_CACHE_LIFETIME) .' GMT');
    header('Pragma: ');
    header('Accept-Ranges: none');
    header('Content-Type: text/css; charset=utf-8');

    if (is_array($css)) {
        $css = implode("\n\n", $css);
    }
355
    echo $css;
356
357
358
    die;
}

359
360
/**
 * Send file not modified headers
361
 *
362
363
364
365
 * @param int $lastmodified
 * @param string $etag
 */
function css_send_unmodified($lastmodified, $etag) {
366
367
    // 60 days only - the revision may get incremented quite often.
    $lifetime = 60*60*24*60;
368
369
370
371
    header('HTTP/1.1 304 Not Modified');
    header('Expires: '. gmdate('D, d M Y H:i:s', time() + $lifetime) .' GMT');
    header('Cache-Control: public, max-age='.$lifetime);
    header('Content-Type: text/css; charset=utf-8');
372
    header('Etag: "'.$etag.'"');
373
374
375
376
377
378
    if ($lastmodified) {
        header('Last-Modified: '. gmdate('D, d M Y H:i:s', $lastmodified) .' GMT');
    }
    die;
}

379
380
381
382
383
384
/**
 * Sends a 404 message about CSS not being found.
 */
function css_send_css_not_found() {
    header('HTTP/1.0 404 not found');
    die('CSS was not found, sorry.');
385
}