forked from djlint/djLint
-
Notifications
You must be signed in to change notification settings - Fork 0
/
indent.py
449 lines (385 loc) · 15.5 KB
/
indent.py
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
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
"""djLint add indentation to html."""
from functools import partial
import json5 as json
import regex as re
from ..helpers import (
inside_ignored_block,
is_ignored_block_closing,
is_ignored_block_opening,
is_safe_closing_tag,
)
from ..settings import Config
from .attributes import format_attributes
def indent_html(rawcode: str, config: Config) -> str:
"""Indent raw code."""
if config.profile not in ["handlebars", "golang"]:
# we can try to fix template tags. ignore handlebars
# this should be done before indenting to line length
# calc is preserved.
def fix_tag_spacing(html: str, match: re.Match) -> str:
if inside_ignored_block(config, html, match):
return match.group()
return f"{match.group(1)} {match.group(2)} {match.group(3)}"
"""
We should have tags like this:
{{ tag }}
{%- tag atrib -%}
"""
func = partial(fix_tag_spacing, rawcode)
rawcode = re.sub(
r"({%-?\+?)[ ]*?(\w(?:(?!%}).)*?)[ ]*?(\+?-?%})", func, rawcode
)
rawcode = re.sub(r"({{)[ ]*?(\w(?:(?!}}).)*?)[ ]*?(\+?-?}})", func, rawcode)
elif config.profile == "handlebars":
def fix_handlebars_template_tags(html: str, match: re.Match) -> str:
if inside_ignored_block(config, html, match):
return match.group()
return f"{match.group(1)} {match.group(2)}"
func = partial(fix_handlebars_template_tags, rawcode)
# handlebars templates
rawcode = re.sub(r"({{#(?:each|if).+?[^ ])(}})", func, rawcode)
rawcode_flat_list = re.split("\n", rawcode)
indent = config.indent
beautified_code = ""
indent_level = 0
in_set_tag = False
is_raw_first_line = False
is_block_raw = False
slt_html = config.indent_html_tags
# here using all tags cause we allow empty tags on one line
always_self_closing_html = config.always_self_closing_html_tags
# here using all tags cause we allow empty tags on one line
slt_template = config.optional_single_line_template_tags
# nested ignored blocks..
ignored_level = 0
for item in rawcode_flat_list:
# if a raw tag first line
if not is_block_raw and is_ignored_block_opening(config, item):
is_raw_first_line = True
# if a raw tag then start ignoring
if is_ignored_block_opening(config, item):
is_block_raw = True
ignored_level += 1
if is_safe_closing_tag(config, item):
ignored_level -= 1
ignored_level = max(ignored_level, 0)
if is_block_raw is True and ignored_level == 0:
is_block_raw = False
if (
re.findall(
rf"^\s*?(?:{config.ignored_inline_blocks})",
item,
flags=re.IGNORECASE | re.VERBOSE | re.MULTILINE,
)
and is_block_raw is False
):
tmp = (indent * indent_level) + item + "\n"
# if a one-line, inline tag, just process it, only if line starts w/ it
# or if it is trailing text
elif (
(
re.findall(
re.compile(
rf"""^(?:[^<\s].*?)? # start of a line, optionally with some text
(?:
(?:<({slt_html})>)(?:.*?)(?:</(?:\1)>) # <span>stuff</span> >>>> match 1
|(?:<({slt_html})\b[^>]+?>)(?:.*?)(?:</(?:\2)>) # <span stuff>stuff</span> >>> match 2
|(?:<(?:{always_self_closing_html})\b[^>]*?/?>) # <img stuff />
|(?:<(?:{slt_html})\b[^>]*?/>) # <img />
|(?:{{%[ ]*?({slt_template})[ ]+?.*?%}})(?:.*?)(?:{{%[ ]+?end(?:\3)[ ]+?.*?%}}) # >>> match 3
|{config.ignored_inline_blocks}
)[ \t]*?
(?:
.*? # anything
(?: # followed by another slt
(?:<({slt_html})>)(?:.*?)(?:</(?:\4)>) # <span>stuff</span> >>>> match 1
|(?:<({slt_html})\b[^>]+?>)(?:.*?)(?:</(?:\5)>) # <span stuff>stuff</span> >>> match 2
|(?:<(?:{always_self_closing_html})\b[^>]*?/?>) # <img stuff />
|(?:<(?:{slt_html})\b[^>]*?/>) # <img />
|(?:{{%[ ]*?({slt_template})[ ]+?.*?%}})(?:.*?)(?:{{%[ ]+?end(?:\6)[ ]+?.*?%}}) # >>> match 3
|{config.ignored_inline_blocks}
)[ \t]*?
)*? # optional of course
[^<]*?$ # with no other tags following until end of line
""",
re.IGNORECASE | re.VERBOSE | re.MULTILINE,
),
item,
)
)
and is_block_raw is False
):
tmp = (indent * indent_level) + item + "\n"
# closing set tag
elif (
config.no_set_formatting is False
and re.search(
re.compile(
r"^(?!.*\{\%).*%\}.*$",
re.IGNORECASE | re.MULTILINE | re.VERBOSE,
),
item,
)
and is_block_raw is False
and in_set_tag is True
):
indent_level = max(indent_level - 1, 0)
in_set_tag = False
tmp = (indent * indent_level) + item + "\n"
# closing curly brace inside a set tag
elif (
config.no_set_formatting is False
and re.search(
re.compile(
r"^[ ]*}|^[ ]*]",
re.IGNORECASE | re.MULTILINE | re.VERBOSE,
),
item,
)
and is_block_raw is False
and in_set_tag is True
):
indent_level = max(indent_level - 1, 0)
tmp = (indent * indent_level) + item + "\n"
# if unindent, move left
elif (
re.search(
config.tag_unindent,
item,
re.IGNORECASE | re.MULTILINE | re.VERBOSE,
)
and is_block_raw is False
and not is_safe_closing_tag(config, item)
# and not ending in a slt like <span><strong></strong>.
and not re.findall(
rf"(<({slt_html})>)(.*?)(</(\2)>[^<]*?$)",
item,
re.IGNORECASE | re.VERBOSE | re.MULTILINE,
)
and not re.findall(
rf"(<({slt_html})\\b[^>]+?>)(.*?)(</(\2)>[^<]*?$)",
item,
re.IGNORECASE | re.VERBOSE | re.MULTILINE,
)
):
# block to catch inline block followed by a non-break tag
if (
len(
re.findall(
rf"(^<({slt_html})>)(.*?)(</(\2)>)",
item,
re.IGNORECASE | re.VERBOSE | re.MULTILINE,
)
or re.findall(
re.compile(
rf"(^<({slt_html})\b[^>]+?>)(.*?)(</(\2)>)",
re.IGNORECASE | re.VERBOSE | re.MULTILINE,
),
item,
)
)
> 0
):
# unindent after instead of before
tmp = (indent * indent_level) + item + "\n"
indent_level = max(indent_level - 1, 0)
else:
indent_level = max(indent_level - 1, 0)
tmp = (indent * indent_level) + item + "\n"
elif (
re.search(
r"^" + str(config.tag_unindent_line),
item,
re.IGNORECASE | re.MULTILINE | re.VERBOSE,
)
and is_block_raw is False
):
tmp = (indent * (indent_level - 1)) + item + "\n"
# if indent, move right
# opening set tag
elif (
config.no_set_formatting is False
and re.search(
re.compile(
r"^([ ]*{%[ ]*?set)(?!.*%}).*$",
re.IGNORECASE | re.MULTILINE | re.VERBOSE,
),
item,
)
and is_block_raw is False
and in_set_tag is False
):
tmp = (indent * indent_level) + item + "\n"
indent_level = indent_level + 1
in_set_tag = True
# opening curly brace inside a set tag
elif (
config.no_set_formatting is False
and re.search(
re.compile(
r"(\{(?![^{}]*%[}\s])(?=[^{}]*$)|\[(?=[^\]]*$))",
re.IGNORECASE | re.MULTILINE | re.VERBOSE,
),
item,
)
and is_block_raw is False
and in_set_tag is True
):
tmp = (indent * indent_level) + item + "\n"
indent_level = indent_level + 1
elif (
re.search(
re.compile(
r"^(?:" + str(config.tag_indent) + r")",
re.IGNORECASE | re.MULTILINE | re.VERBOSE,
),
item,
)
and is_block_raw is False
):
tmp = (indent * indent_level) + item + "\n"
indent_level = indent_level + 1
elif is_raw_first_line is True or (
is_safe_closing_tag(config, item) and is_block_raw is False
):
tmp = (indent * indent_level) + item + "\n"
elif is_block_raw is True or not item.strip():
tmp = item + "\n"
# otherwise, just leave same level
elif not config.preserve_leading_space:
# if we are not trying to preserve indenting
# on text, the add it now.
tmp = (indent * indent_level) + item + "\n"
else:
tmp = item + "\n"
# if a opening raw tag then start ignoring.. only if there is no closing tag
# on the same line
if is_ignored_block_opening(config, item):
is_block_raw = True
is_raw_first_line = False
# if a normal tag, we can try to expand attributes
elif is_block_raw is False:
# get leading space, and attributes
func = partial(format_attributes, config, item)
tmp = re.sub(
re.compile(
rf"(\s*?)(<(?:{config.indent_html_tags})\b)((?:\"[^\"]*\"|'[^']*'|{{[^}}]*}}|[^'\">{{}}\/])+?)(\s?/?>)",
re.VERBOSE | re.IGNORECASE,
),
func,
tmp,
)
# turn off raw block if we hit end - for one line raw blocks, but not an inline raw
if is_ignored_block_closing(config, item):
if not is_safe_closing_tag(config, item):
ignored_level -= 1
ignored_level = max(ignored_level, 0)
if ignored_level == 0:
is_block_raw = False
# set a rule for tmp content to have outer double quotes only for jinja
if config.profile == "jinja":
tmp = re.sub(r"=(')(.*?)(')", r'="\2"', tmp)
beautified_code = beautified_code + tmp
# try to fix internal formatting of set tag
def format_data(config: Config, contents: str, tag_size: int, leading_space) -> str:
try:
# try to format the contents as json
data = json.loads(contents)
contents = json.dumps(
data, trailing_commas=False, ensure_ascii=False, quote_keys=True
)
if tag_size + len(contents) >= config.max_line_length:
# if the line is too long we can indent the json
contents = json.dumps(
data,
indent=config.indent_size,
trailing_commas=False,
ensure_ascii=False,
quote_keys=True,
)
except:
# was not json.. try to eval as set
try:
evaluated = str(eval(contents))
# need to unwrap the eval
contents = (
evaluated[1:-1]
if contents[:1] != "(" and evaluated[:1] == "("
else evaluated
)
except:
contents = contents.strip()
return (f"\n{leading_space}").join(contents.splitlines())
def format_set(config: Config, html: str, match: re.Match) -> str:
if inside_ignored_block(config, html, match):
return match.group()
leading_space = match.group(1)
open_bracket = match.group(2)
tag = match.group(3)
close_bracket = match.group(5)
contents = match.group(4).strip()
contents_split = contents.split("=", 1)
if len(contents_split) > 1:
contents = (
contents_split[0].strip()
+ " = "
+ format_data(
config,
contents_split[-1],
len(f"{open_bracket} {tag} {close_bracket}"),
leading_space,
)
)
return f"{leading_space}{open_bracket} {tag} {contents} {close_bracket}"
def format_function(config: Config, html: str, match: re.Match) -> str:
if inside_ignored_block(config, html, match):
return match.group()
leading_space = match.group(1)
open_bracket = match.group(2)
tag = match.group(3).strip()
index = (match.group(5) or "").strip()
close_bracket = match.group(6)
contents = format_data(
config,
match.group(4).strip()[1:-1],
len(f"{open_bracket} {tag}() {close_bracket}"),
leading_space,
)
cleaned_match = (
f"{leading_space}{open_bracket} {tag}({contents}){index} {close_bracket}"
)
if config.profile == "jinja":
# remove inconsistent quotes from the content
contents = contents.replace('"', "'")
# check for trailing or leading spaces inside the single quotes and remove them
contents = re.sub(r"(?<=')\s+|\s+(?=')", "", contents)
# update cleaned match
cleaned_match = f"{leading_space}{open_bracket} {tag}({contents}){index} {close_bracket}"
# strip any potential white space from the cleaned match
cleaned_match = cleaned_match.strip()
return cleaned_match
if config.no_set_formatting is False:
func = partial(format_set, config, beautified_code)
# format set contents
beautified_code = re.sub(
re.compile(
r"([ ]*)({%-?)[ ]*(set)[ ]+?((?:(?!%}).)*?)(-?%})",
flags=re.IGNORECASE | re.MULTILINE | re.VERBOSE | re.DOTALL,
),
func,
beautified_code,
)
if config.no_function_formatting is False:
func = partial(format_function, config, beautified_code)
# format function contents
beautified_code = re.sub(
re.compile(
r"([ ]*)({{-?\+?)[ ]*?((?:(?!}}).)*?\w)(\((?:\"[^\"]*\"|'[^']*'|[^\)])*?\)[ ]*)((?:\[[^\]]*?\]|\.\d+)[ ]*)?((?:(?!}}).)*?-?\+?}})",
flags=re.IGNORECASE | re.MULTILINE | re.VERBOSE | re.DOTALL,
),
func,
beautified_code,
)
if not config.preserve_blank_lines:
beautified_code = beautified_code.lstrip()
return beautified_code.rstrip() + "\n"