← Back to branch summary

~didrocks/+junk/face-detection-15.04

« back to all changes in this revision

Viewing changes to facedetection/www/bower_components/prism/components/prism-haml.js

  • Committer: Didier Roche
  • Date: 2016-05-10 23:09:11 UTC
  • Revision ID: didier.roche@canonical.com-20160510230911-c7xr490zrj3yrzxd
New version

Show diffs side-by-side

added added

removed removed

Lines of Context:
facedetection/www/bower_components/prism/components/prism-haml.js
 
1
/* TODO
 
2
        Handle multiline code after tag
 
3
            %foo= some |
 
4
                        multiline |
 
5
                        code |
 
6
*/
 
7
 
 
8
(function(Prism) {
 
9
 
 
10
        Prism.languages.haml = {
 
11
                // Multiline stuff should appear before the rest
 
12
 
 
13
                'multiline-comment': {
 
14
                        pattern: /((?:^|\r?\n|\r)([\t ]*))(?:\/|-#).*((?:\r?\n|\r)\2[\t ]+.+)*/,
 
15
                        lookbehind: true,
 
16
                        alias: 'comment'
 
17
                },
 
18
 
 
19
                'multiline-code': [
 
20
                        {
 
21
                                pattern: /((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*,[\t ]*((?:\r?\n|\r)\2[\t ]+.*,[\t ]*)*((?:\r?\n|\r)\2[\t ]+.+)/,
 
22
                                lookbehind: true,
 
23
                                inside: {
 
24
                                        rest: Prism.languages.ruby
 
25
                                }
 
26
                        },
 
27
                        {
 
28
                                pattern: /((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*\|[\t ]*((?:\r?\n|\r)\2[\t ]+.*\|[\t ]*)*/,
 
29
                                lookbehind: true,
 
30
                                inside: {
 
31
                                        rest: Prism.languages.ruby
 
32
                                }
 
33
                        }
 
34
                ],
 
35
 
 
36
                // See at the end of the file for known filters
 
37
                'filter': {
 
38
                        pattern: /((?:^|\r?\n|\r)([\t ]*)):[\w-]+((?:\r?\n|\r)(?:\2[\t ]+.+|\s*?(?=\r?\n|\r)))+/,
 
39
                        lookbehind: true,
 
40
                        inside: {
 
41
                                'filter-name': {
 
42
                                        pattern: /^:[\w-]+/,
 
43
                                        alias: 'variable'
 
44
                                }
 
45
                        }
 
46
                },
 
47
 
 
48
                'markup': {
 
49
                        pattern: /((?:^|\r?\n|\r)[\t ]*)<.+/,
 
50
                        lookbehind: true,
 
51
                        inside: {
 
52
                                rest: Prism.languages.markup
 
53
                        }
 
54
                },
 
55
                'doctype': {
 
56
                        pattern: /((?:^|\r?\n|\r)[\t ]*)!!!(?: .+)?/,
 
57
                        lookbehind: true
 
58
                },
 
59
                'tag': {
 
60
                        // Allows for one nested group of braces
 
61
                        pattern: /((?:^|\r?\n|\r)[\t ]*)[%.#][\w\-#.]*[\w\-](?:\([^)]+\)|\{(?:\{[^}]+\}|[^}])+\}|\[[^\]]+\])*[\/<>]*/,
 
62
                        lookbehind: true,
 
63
                        inside: {
 
64
                                'attributes': [
 
65
                                        {
 
66
                                                // Lookbehind tries to prevent interpolations for breaking it all
 
67
                                                // Allows for one nested group of braces
 
68
                                                pattern: /(^|[^#])\{(?:\{[^}]+\}|[^}])+\}/,
 
69
                                                lookbehind: true,
 
70
                                                inside: {
 
71
                                                        rest: Prism.languages.ruby
 
72
                                                }
 
73
                                        },
 
74
                                        {
 
75
                                                pattern: /\([^)]+\)/,
 
76
                                                inside: {
 
77
                                                        'attr-value': {
 
78
                                                                pattern: /(=\s*)(?:"(?:\\?.)*?"|[^)\s]+)/,
 
79
                                                                lookbehind: true
 
80
                                                        },
 
81
                                                        'attr-name': /[\w:-]+(?=\s*!?=|\s*[,)])/,
 
82
                                                        'punctuation': /[=(),]/
 
83
                                                }
 
84
                                        },
 
85
                                        {
 
86
                                                pattern: /\[[^\]]+\]/,
 
87
                                                inside: {
 
88
                                                        rest: Prism.languages.ruby
 
89
                                                }
 
90
                                        }
 
91
                                ],
 
92
                                'punctuation': /[<>]/
 
93
                        }
 
94
                },
 
95
                'code': {
 
96
                        pattern: /((?:^|\r?\n|\r)[\t ]*(?:[~-]|[&!]?=)).+/,
 
97
                        lookbehind: true,
 
98
                        inside: {
 
99
                                rest: Prism.languages.ruby
 
100
                        }
 
101
                },
 
102
                // Interpolations in plain text
 
103
                'interpolation': {
 
104
                        pattern: /#\{[^}]+\}/,
 
105
                        inside: {
 
106
                                'delimiter': {
 
107
                                        pattern: /^#\{|\}$/,
 
108
                                        alias: 'punctuation'
 
109
                                },
 
110
                                rest: Prism.languages.ruby
 
111
                        }
 
112
                },
 
113
                'punctuation': {
 
114
                        pattern: /((?:^|\r?\n|\r)[\t ]*)[~=\-&!]+/,
 
115
                        lookbehind: true
 
116
                }
 
117
        };
 
118
 
 
119
        var filter_pattern = '((?:^|\\r?\\n|\\r)([\\t ]*)):{{filter_name}}((?:\\r?\\n|\\r)(?:\\2[\\t ]+.+|\\s*?(?=\\r?\\n|\\r)))+';
 
120
 
 
121
        // Non exhaustive list of available filters and associated languages
 
122
        var filters = [
 
123
                'css',
 
124
                {filter:'coffee',language:'coffeescript'},
 
125
                'erb',
 
126
                'javascript',
 
127
                'less',
 
128
                'markdown',
 
129
                'ruby',
 
130
                'scss',
 
131
                'textile'
 
132
        ];
 
133
        var all_filters = {};
 
134
        for (var i = 0, l = filters.length; i < l; i++) {
 
135
                var filter = filters[i];
 
136
                filter = typeof filter === 'string' ? {filter: filter, language: filter} : filter;
 
137
                if (Prism.languages[filter.language]) {
 
138
                        all_filters['filter-' + filter.filter] = {
 
139
                                pattern: RegExp(filter_pattern.replace('{{filter_name}}', filter.filter)),
 
140
                                lookbehind: true,
 
141
                                inside: {
 
142
                                        'filter-name': {
 
143
                                                pattern: /^:[\w-]+/,
 
144
                                                alias: 'variable'
 
145
                                        },
 
146
                                        rest: Prism.languages[filter.language]
 
147
                                }
 
148
                        }
 
149
                }
 
150
        }
 
151
 
 
152
        Prism.languages.insertBefore('haml', 'filter', all_filters);
 
153
 
 
154
}(Prism));
 
 
b'\\ No newline at end of file'