194 |
200 | Doogie Howser Comes Out
195 | 2006-11-05
196 |
197 | Neil Patrick Harris would like to dispel any rumors that he is straight
198 |
199 | \n" 148 | self.after = "" # rendered text at end of node, e.g. "\n
" 149 | 150 | @classmethod 151 | def create_root(cls, compiler): 152 | return cls(None, compiler) 153 | 154 | def render(self): 155 | # Render (sets self.before and self.after) 156 | self._render_children() 157 | # Post-render (nodes can modify the rendered text of other nodes) 158 | self._post_render() 159 | # Generate HTML 160 | return self._generate_html() 161 | 162 | def render_newlines(self): 163 | return "\n" * (self.newlines + 1) 164 | 165 | def _render_children(self): 166 | for child in self.children: 167 | child._render() 168 | 169 | def _post_render(self): 170 | for child in self.children: 171 | child._post_render() 172 | 173 | def _generate_html(self): 174 | output = [self.before] 175 | for child in self.children: 176 | output.append(child.before) 177 | output += [gc._generate_html() for gc in child.children] 178 | output.append(child.after) 179 | output.append(self.after) 180 | return "".join(output) 181 | 182 | def replace_inline_variables(self, content): 183 | inline_var_regex, escaped_var_regex = self.compiler.inline_variable_regexes 184 | 185 | content = inline_var_regex.sub(r"{{ \2 }}", content) 186 | content = escaped_var_regex.sub(r"\1", content) 187 | return content 188 | 189 | def add_node(self, node): 190 | if self._should_go_inside_last_node(node): 191 | self.children[-1].add_node(node) 192 | else: 193 | self.add_child(node) 194 | 195 | def _should_go_inside_last_node(self, node): 196 | return len(self.children) > 0 and ( 197 | node.indentation > self.children[-1].indentation 198 | or (node.indentation == self.children[-1].indentation and self.children[-1].should_contain(node)) 199 | ) 200 | 201 | def should_contain(self, node): 202 | return False 203 | 204 | def debug_tree(self): # pragma: no cover 205 | return "\n".join(self._debug_tree([self])) 206 | 207 | def _debug_tree(self, nodes): # pragma: no cover 208 | output = [] 209 | for n in nodes: 210 | output.append("%s%s" % (" " * (n.indentation + 2), n)) 211 | if n.children: 212 | output += self._debug_tree(n.children) 213 | return output 214 | 215 | def __repr__(self): # pragma: no cover 216 | return "%s" % type(self).__name__ 217 | 218 | 219 | class LineNode(Node): 220 | """ 221 | Base class of nodes which are a single line of Haml 222 | """ 223 | 224 | def __init__(self, line, indent, compiler): 225 | super(LineNode, self).__init__(indent, compiler) 226 | 227 | self.haml = line.rstrip() 228 | 229 | def __repr__(self): # pragma: no cover 230 | return "%s(indent=%d, newlines=%d): %s" % (type(self).__name__, self.indentation, self.newlines, self.haml) 231 | 232 | 233 | class PlaintextNode(LineNode): 234 | """ 235 | Node that is not modified or processed when rendering 236 | """ 237 | 238 | def _render(self): 239 | text = self.replace_inline_variables(self.haml) 240 | 241 | # remove escape character 242 | if text and text[0] == HAML_ESCAPE: 243 | text = text.replace(HAML_ESCAPE, "", 1) 244 | 245 | self.before = "%s%s" % (self.indent, text) 246 | if self.children: 247 | self.before += self.render_newlines() 248 | else: 249 | self.after = self.render_newlines() 250 | 251 | self._render_children() 252 | 253 | 254 | class ElementNode(Node): 255 | """ 256 | An HTML tag node, e.g. %span 257 | """ 258 | 259 | def __init__(self, element, indent, compiler): 260 | super(ElementNode, self).__init__(indent, compiler) 261 | 262 | self.element = element 263 | 264 | def _render(self): 265 | self.before = self._render_before(self.element) 266 | self.after = self._render_after(self.element) 267 | self._render_children() 268 | 269 | def _render_before(self, element): 270 | """ 271 | Render opening tag and inline content 272 | """ 273 | start = ["%s<%s" % (self.indent, element.tag)] 274 | 275 | attributes = element.render_attributes(self.compiler.options) 276 | if attributes: 277 | start.append(" " + self.replace_inline_variables(attributes)) 278 | 279 | content = self._render_inline_content(self.element.inline_content) 280 | 281 | if element.nuke_inner_whitespace and content: 282 | content = content.strip() 283 | 284 | if element.self_close and not content: 285 | start.append(">" if self.compiler.options.html else " />") 286 | elif content: 287 | start.append(">%s" % content) 288 | elif self.children: 289 | start.append(">%s" % (self.render_newlines())) 290 | else: 291 | start.append(">") 292 | return "".join(start) 293 | 294 | def _render_after(self, element): 295 | """ 296 | Render closing tag 297 | """ 298 | if element.inline_content: 299 | return "%s" % (element.tag, self.render_newlines()) 300 | elif element.self_close: 301 | return self.render_newlines() 302 | elif self.children: 303 | return "%s\n" % (self.indent, element.tag) 304 | else: 305 | return "\n" % element.tag 306 | 307 | def _post_render(self): 308 | # inner whitespace removal 309 | if self.element.nuke_inner_whitespace: 310 | self.before = self.before.rstrip() 311 | self.after = self.after.lstrip() 312 | 313 | if self.children: 314 | node = self 315 | if node.children: 316 | node.children[0].before = node.children[0].before.lstrip() 317 | 318 | if node.children: 319 | node.children[-1].after = node.children[-1].after.rstrip() 320 | 321 | # outer whitespace removal 322 | if self.element.nuke_outer_whitespace: 323 | left_sibling = self.left_sibling() 324 | if left_sibling: 325 | # If node has left sibling, strip whitespace after left sibling 326 | left_sibling.after = left_sibling.after.rstrip() 327 | left_sibling.newlines = 0 328 | else: 329 | # If not, whitespace comes from it's parent node, 330 | # so strip whitespace before the node 331 | self.parent.before = self.parent.before.rstrip() 332 | self.parent.newlines = 0 333 | 334 | self.before = self.before.lstrip() 335 | self.after = self.after.rstrip() 336 | 337 | right_sibling = self.right_sibling() 338 | if right_sibling: 339 | right_sibling.before = right_sibling.before.lstrip() 340 | else: 341 | self.parent.after = self.parent.after.lstrip() 342 | self.parent.newlines = 0 343 | 344 | super(ElementNode, self)._post_render() 345 | 346 | def _render_inline_content(self, inline_content): 347 | if inline_content is None or len(inline_content) == 0: 348 | return None 349 | 350 | if self.element.django_variable: 351 | content = "{{ " + inline_content.strip() + " }}" 352 | return content 353 | else: 354 | return self.replace_inline_variables(inline_content) 355 | 356 | 357 | class CommentNode(LineNode): 358 | """ 359 | An HTML comment node, e.g. / This is a comment 360 | """ 361 | 362 | def _render(self): 363 | self.after = "-->\n" 364 | if self.children: 365 | self.before = "\n" 386 | self._render_children() 387 | 388 | 389 | class DoctypeNode(LineNode): 390 | """ 391 | An XML doctype node, e.g. !!! 5 392 | """ 393 | 394 | def _render(self): 395 | doctype = self.haml.lstrip(DOCTYPE_PREFIX).strip().lower() 396 | 397 | self.before = self.get_header(doctype, self.compiler.options) 398 | self.after = self.render_newlines() 399 | 400 | def get_header(self, doctype, options): 401 | if doctype.startswith("xml"): 402 | if options.html: 403 | return "" 404 | parts = doctype.split() 405 | encoding = parts[1] if len(parts) > 1 else "utf-8" 406 | return "" % ( 407 | options.attr_wrapper, 408 | options.attr_wrapper, 409 | options.attr_wrapper, 410 | encoding, 411 | options.attr_wrapper, 412 | ) 413 | elif options.html5: 414 | return "" 415 | elif options.xhtml: 416 | if doctype == "5": 417 | return "" 418 | else: 419 | return XHTML_DOCTYPES.get(doctype, XHTML_DOCTYPES[""]) 420 | else: 421 | return HTML4_DOCTYPES.get(doctype, HTML4_DOCTYPES[""]) 422 | 423 | 424 | class HamlCommentNode(LineNode): 425 | """ 426 | A Haml comment node, e.g. -# This is a comment 427 | """ 428 | 429 | def _render(self): 430 | self.after = self.render_newlines()[1:] 431 | 432 | def _post_render(self): 433 | pass 434 | 435 | 436 | class VariableNode(LineNode): 437 | """ 438 | A Django variable node, e.g. =person.name 439 | """ 440 | 441 | def __init__(self, haml, indent, compiler): 442 | super(VariableNode, self).__init__(haml, indent, compiler) 443 | 444 | def _render(self): 445 | tag_content = self.haml.lstrip(VARIABLE_PREFIX) 446 | self.before = "%s{{ %s }}" % (self.indent, tag_content.strip()) 447 | self.after = self.render_newlines() 448 | 449 | def _post_render(self): 450 | pass 451 | 452 | 453 | class TagNode(LineNode): 454 | """ 455 | A Django/Jinja server-side tag node, e.g. -block 456 | """ 457 | 458 | def __init__(self, haml, indent, compiler): 459 | super(TagNode, self).__init__(haml, indent, compiler) 460 | 461 | self.tag_statement = self.haml.lstrip(TAG_PREFIX).strip() 462 | self.tag_name = self.tag_statement.split(" ")[0] 463 | 464 | if self.tag_name in self.compiler.self_closing_tags.values(): 465 | raise ParseException("Unexpected closing tag for self-closing tag %s" % self.tag_name) 466 | 467 | def _render(self): 468 | self.before = "%s{%% %s %%}" % (self.indent, self.tag_statement) 469 | 470 | closing_tag = self.compiler.self_closing_tags.get(self.tag_name) 471 | 472 | if closing_tag: 473 | if self.tag_name == "block" and self.compiler.options.endblock_names: 474 | block_name = self.tag_statement.split(" ")[1] 475 | closing_tag += " " + block_name 476 | 477 | self.before += self.render_newlines() 478 | self.after = "%s{%% %s %%}%s" % (self.indent, closing_tag, self.render_newlines()) 479 | else: 480 | if self.children: 481 | self.before += self.render_newlines() 482 | else: 483 | self.after = self.render_newlines() 484 | self._render_children() 485 | 486 | def should_contain(self, node): 487 | return isinstance(node, TagNode) and node.tag_name in self.compiler.tags_may_contain.get(self.tag_name, "") 488 | 489 | 490 | class FilterNode(Node): 491 | """ 492 | A type filter, e.g. :javascript 493 | """ 494 | 495 | def __init__(self, filter_name, content, indent, compiler): 496 | super(FilterNode, self).__init__(indent, compiler) 497 | 498 | self.filter_name = filter_name 499 | self.content = content 500 | 501 | def _render(self): 502 | content = textwrap.dedent(self.content) 503 | 504 | filter_func = get_filter(self.filter_name) 505 | content = filter_func(content, self.compiler.options) 506 | 507 | content = self.indent + content.replace("\n", "\n" + self.indent) 508 | 509 | self.before = content 510 | self.after = self.render_newlines() if self.content else "" 511 | 512 | def _post_render(self): 513 | pass 514 | 515 | def __repr__(self): # pragma: no cover 516 | return "%s(indent=%d, newlines=%d, filter=%s): %s" % ( 517 | type(self).__name__, 518 | self.indentation, 519 | self.newlines, 520 | self.filter_name, 521 | self.content, 522 | ) 523 | -------------------------------------------------------------------------------- /hamlpy/parser/utils.py: -------------------------------------------------------------------------------- 1 | from enum import Enum 2 | 3 | from .core import Stream 4 | 5 | DJANGO_TAG_OPEN = "{%" 6 | DJANGO_TAG_CLOSE = "%}" 7 | DJANGO_EXP_OPEN = "{{" 8 | DJANGO_EXP_CLOSE = "}}" 9 | HTML_CHARS = {"&": "&", "<": "<", ">": ">", '"': """, "'": "'"} 10 | 11 | 12 | class EscapeState(Enum): 13 | normal = 0 14 | in_tag = 1 15 | in_exp = 2 16 | 17 | 18 | def html_escape(text): 19 | """ 20 | Escapes HTML entities, matching substitutions used by the Ruby Haml library. Entities that occur inside Django tags 21 | or expressions are not escaped. 22 | """ 23 | new_text = [] 24 | state = EscapeState.normal 25 | stream = Stream(text) 26 | 27 | while stream.ptr < stream.length: 28 | ch = stream.text[stream.ptr] 29 | ch2 = stream.text[stream.ptr : stream.ptr + 2] 30 | 31 | if ch2 == DJANGO_TAG_OPEN or ch2 == DJANGO_EXP_OPEN: 32 | state = EscapeState.in_tag if ch2 == DJANGO_TAG_OPEN else EscapeState.in_exp 33 | stream.ptr += 2 34 | new_text.append(ch2) 35 | elif (state == EscapeState.in_tag and ch2 == DJANGO_TAG_CLOSE) or ( 36 | state == EscapeState.in_exp and ch2 == DJANGO_EXP_CLOSE 37 | ): 38 | state = EscapeState.normal 39 | stream.ptr += 2 40 | new_text.append(ch2) 41 | else: 42 | stream.ptr += 1 43 | new_text.append(HTML_CHARS.get(ch, ch) if state == EscapeState.normal else ch) 44 | 45 | return "".join(new_text) 46 | -------------------------------------------------------------------------------- /hamlpy/template/__init__.py: -------------------------------------------------------------------------------- 1 | from .loaders import haml_loaders as _loaders 2 | 3 | locals().update(_loaders) 4 | -------------------------------------------------------------------------------- /hamlpy/template/loaders.py: -------------------------------------------------------------------------------- 1 | import os 2 | 3 | from django.conf import settings 4 | from django.template import TemplateDoesNotExist 5 | from django.template.loaders import app_directories, filesystem 6 | 7 | from hamlpy import HAML_EXTENSIONS 8 | from hamlpy.compiler import Compiler 9 | from hamlpy.template.utils import get_django_template_loaders 10 | 11 | # Get options from Django settings 12 | options = {} 13 | 14 | if hasattr(settings, "HAMLPY_ATTR_WRAPPER"): 15 | options.update(attr_wrapper=settings.HAMLPY_ATTR_WRAPPER) 16 | 17 | if hasattr(settings, "HAMLPY_DJANGO_INLINE_STYLE"): 18 | options.update(django_inline_style=settings.HAMLPY_DJANGO_INLINE_STYLE) 19 | 20 | 21 | def get_haml_loader(loader): 22 | class Loader(loader.Loader): 23 | def get_contents(self, origin): 24 | # Django>=1.9 25 | contents = super(Loader, self).get_contents(origin) 26 | name, _extension = os.path.splitext(origin.template_name) 27 | # os.path.splitext always returns a period at the start of extension 28 | extension = _extension.lstrip(".") 29 | 30 | if extension in HAML_EXTENSIONS: 31 | compiler = Compiler(options=options) 32 | return compiler.process(contents) 33 | 34 | return contents 35 | 36 | def load_template_source(self, template_name, *args, **kwargs): 37 | # Django<1.9 38 | name, _extension = os.path.splitext(template_name) 39 | # os.path.splitext always returns a period at the start of extension 40 | extension = _extension.lstrip(".") 41 | 42 | if extension in HAML_EXTENSIONS: 43 | try: 44 | haml_source, template_path = super(Loader, self).load_template_source( 45 | self._generate_template_name(name, extension), *args, **kwargs 46 | ) 47 | except TemplateDoesNotExist: # pragma: no cover 48 | pass 49 | else: 50 | compiler = Compiler(options=options) 51 | html = compiler.process(haml_source) 52 | 53 | return html, template_path 54 | 55 | raise TemplateDoesNotExist(template_name) 56 | 57 | load_template_source.is_usable = True 58 | 59 | @staticmethod 60 | def _generate_template_name(name, extension="hamlpy"): 61 | return "%s.%s" % (name, extension) 62 | 63 | return Loader 64 | 65 | 66 | haml_loaders = dict((name, get_haml_loader(loader)) for (name, loader) in get_django_template_loaders()) 67 | 68 | HamlPyFilesystemLoader = get_haml_loader(filesystem) 69 | HamlPyAppDirectoriesLoader = get_haml_loader(app_directories) 70 | -------------------------------------------------------------------------------- /hamlpy/template/templatize.py: -------------------------------------------------------------------------------- 1 | """ 2 | This module decorates the django templatize function to parse haml templates before the translation utility extracts 3 | tags from it. 4 | """ 5 | 6 | import os 7 | 8 | from django.utils import translation 9 | 10 | from hamlpy import HAML_EXTENSIONS 11 | from hamlpy.compiler import Compiler 12 | 13 | 14 | def patch_templatize(func): 15 | def templatize(src, origin=None, charset="utf-8"): 16 | # if the template has no origin then don't attempt to convert it because we don't know if it's Haml 17 | if origin: 18 | extension = os.path.splitext(origin)[1][1:].lower() 19 | 20 | if extension in HAML_EXTENSIONS: 21 | compiler = Compiler() 22 | src = compiler.process(src) 23 | 24 | return func(src, origin=origin) 25 | 26 | return templatize 27 | 28 | 29 | translation.templatize = patch_templatize(translation.templatize) 30 | -------------------------------------------------------------------------------- /hamlpy/template/utils.py: -------------------------------------------------------------------------------- 1 | from importlib import machinery 2 | from os import listdir 3 | from os.path import dirname, splitext 4 | 5 | from django.template import loaders 6 | 7 | MODULE_EXTENSIONS = tuple(machinery.all_suffixes()) 8 | 9 | 10 | def get_django_template_loaders(): 11 | return [ 12 | (loader.__name__.rsplit(".", 1)[1], loader) for loader in get_submodules(loaders) if hasattr(loader, "Loader") 13 | ] 14 | 15 | 16 | def get_submodules(package): 17 | submodules = ("%s.%s" % (package.__name__, module) for module in package_contents(package)) 18 | return [__import__(module, {}, {}, [module.rsplit(".", 1)[-1]]) for module in submodules] 19 | 20 | 21 | def package_contents(package): 22 | package_path = dirname(loaders.__file__) 23 | contents = set([splitext(module)[0] for module in listdir(package_path) if module.endswith(MODULE_EXTENSIONS)]) 24 | return contents 25 | -------------------------------------------------------------------------------- /hamlpy/test/__init__.py: -------------------------------------------------------------------------------- 1 | import os 2 | 3 | import django 4 | 5 | os.environ["DJANGO_SETTINGS_MODULE"] = "hamlpy.test.settings" 6 | django.setup() 7 | -------------------------------------------------------------------------------- /hamlpy/test/settings.py: -------------------------------------------------------------------------------- 1 | DEBUG = True 2 | 3 | DATABASES = {} 4 | 5 | INSTALLED_APPS = ("hamlpy",) 6 | 7 | TEMPLATES = [ 8 | { 9 | "BACKEND": "django.template.backends.django.DjangoTemplates", 10 | "DIRS": ["hamlpy/test/templates"], 11 | "OPTIONS": { 12 | "loaders": [ 13 | "hamlpy.template.loaders.HamlPyFilesystemLoader", 14 | "hamlpy.template.loaders.HamlPyAppDirectoriesLoader", 15 | "django.template.loaders.filesystem.Loader", 16 | "django.template.loaders.app_directories.Loader", 17 | ], 18 | "debug": True, 19 | }, 20 | } 21 | ] 22 | 23 | SECRET_KEY = "tots top secret" 24 | -------------------------------------------------------------------------------- /hamlpy/test/templates/allIfTypesTest.hamlpy: -------------------------------------------------------------------------------- 1 | - if something 2 | Cool 3 | - ifchanged something 4 | Changed 5 | - ifequal something "booya" 6 | Equal 7 | - ifnotequal something "blamo" 8 | No Equal 9 | - ifchanged something 10 | Changed 11 | - else 12 | No Changed 13 | - ifequal something "booya" 14 | Equal 15 | - else 16 | No Equal 17 | - ifnotequal something "blamo" 18 | No Equal 19 | - else 20 | Equal -------------------------------------------------------------------------------- /hamlpy/test/templates/allIfTypesTest.html: -------------------------------------------------------------------------------- 1 | {% if something %} 2 | Cool 3 | {% endif %} 4 | {% ifchanged something %} 5 | Changed 6 | {% endifchanged %} 7 | {% ifequal something "booya" %} 8 | Equal 9 | {% endifequal %} 10 | {% ifnotequal something "blamo" %} 11 | No Equal 12 | {% endifnotequal %} 13 | {% ifchanged something %} 14 | Changed 15 | {% else %} 16 | No Changed 17 | {% endifchanged %} 18 | {% ifequal something "booya" %} 19 | Equal 20 | {% else %} 21 | No Equal 22 | {% endifequal %} 23 | {% ifnotequal something "blamo" %} 24 | No Equal 25 | {% else %} 26 | Equal 27 | {% endifnotequal %} 28 | -------------------------------------------------------------------------------- /hamlpy/test/templates/classIdMixtures.hamlpy: -------------------------------------------------------------------------------- 1 | %div#Article.article.entry.hover:no-underline{'id':'123', class:'true'} 2 | Now this is interesting 3 | %div.article.entry.hover:no-underline#Article(id='123' class='true') 4 | Now this is really interesting 5 | -------------------------------------------------------------------------------- /hamlpy/test/templates/classIdMixtures.html: -------------------------------------------------------------------------------- 1 |
2 | Now this is interesting
3 |
4 |
5 | Now this is really interesting
6 |
7 |
--------------------------------------------------------------------------------
/hamlpy/test/templates/djangoBase.hamlpy:
--------------------------------------------------------------------------------
1 | %h1
2 | - block title
3 | .
4 | - block content
--------------------------------------------------------------------------------
/hamlpy/test/templates/djangoBase.html:
--------------------------------------------------------------------------------
1 | 2 | {% block title %} 3 | {% endblock %} 4 |
5 |
6 | {% block content %}
7 | {% endblock %}
8 |
9 |
--------------------------------------------------------------------------------
/hamlpy/test/templates/djangoCombo.hamlpy:
--------------------------------------------------------------------------------
1 | - extends "djangoBase.hamlpy"
2 |
3 | - block title
4 | = section.title
5 |
6 | - block content
7 | %h2= section.subtitle
8 |
9 | - for story in story_list
10 | %h3
11 | %a{'href':'{{ story.get_absolute_url }}'}
12 | = story.headline|upper
13 | %p= story.tease|truncatewords:"100"
14 |
--------------------------------------------------------------------------------
/hamlpy/test/templates/djangoCombo.html:
--------------------------------------------------------------------------------
1 | {% extends "djangoBase.hamlpy" %}
2 |
3 | {% block title %}
4 | {{ section.title }}
5 |
6 | {% endblock %}
7 | {% block content %}
8 | {{ section.subtitle }}
9 | 10 | {% for story in story_list %} 11 |12 | 13 | {{ story.headline|upper }} 14 | 15 |
16 |{{ story.tease|truncatewords:"100" }}
17 | {% endfor %} 18 | {% endblock %} 19 | -------------------------------------------------------------------------------- /hamlpy/test/templates/filterMultilineIgnore.hamlpy: -------------------------------------------------------------------------------- 1 | .multilinetest1{id:'{{myId}}', 2 | alt: "{{nothing}}"} 3 | :plain 4 | These { { braces 5 | 6 | should } not be interpreted as a multiline string 7 | :preserve 8 | These { { braces 9 | 10 | should } not be interpreted as a multiline string 11 | :css 12 | .test { 13 | display: inline; 14 | } 15 | :javascript 16 | These { 17 | Braces should { 18 | also 19 | } be { ignored 20 | 21 | .multilinetest2{id:'{{myId}}', 22 | class:'{{myClass}}', 23 | alt: ""} 24 | / The following is from hjonathan, issue #67 25 | %head 26 | .blah 27 | :javascript 28 | $(document).ready(function(){ 29 | $("#form{{form.initial.id}}").submit(form_submit); 30 | //Double nesting 31 | $(function() { 32 | blahblahblah 33 | }); 34 | 35 | // Javascript comment 36 | }); 37 | :javascript 38 | $(document).ready(function(){ 39 | $("#form{{form.initial.id}}").submit(form_submit); 40 | // Javascript comment 41 | }); 42 | :css 43 | .someClass { 44 | width: 100px; 45 | } 46 | :cdata 47 | if (a < b && a < 0) 48 | { 49 | return 1; 50 | } 51 | -# Regression from Culebron (Github issue #90) 52 | :javascript 53 | ( 54 | { 55 | a 56 | } 57 | ); 58 | :javascript 59 | 60 | { 61 | a 62 | } 63 | ) 64 | -------------------------------------------------------------------------------- /hamlpy/test/templates/filterMultilineIgnore.html: -------------------------------------------------------------------------------- 1 | 2 | These { { braces 3 | 4 | should } not be interpreted as a multiline string 5 | These { { braces should } not be interpreted as a multiline string 6 | 13 | 21 | 22 | 23 | 24 |
25 |
38 |
39 |
47 |
54 |
60 |
61 |
70 |
79 |
--------------------------------------------------------------------------------
/hamlpy/test/templates/filters.hamlpy:
--------------------------------------------------------------------------------
1 | :escaped
2 | <"&'>
3 | :javascript
4 | $(document).ready(function(){
5 | $("#form{{form.initial.id}}").submit(form_submit);
6 | // Javascript comment
7 | });
8 | :css
9 | .someClass {
10 | width: 100px;
11 | }
12 | :stylus
13 | .someClass
14 | width: 100px
15 | :less
16 | .someClass {
17 | width: 100px;
18 | }
19 | :sass
20 | .someClass {
21 | width: 100px;
22 | }
23 | :cdata
24 | if (a < b && a < 0)
25 | {
26 | return 1;
27 | }
28 | :python
29 | a=1
30 | for i in range(5):
31 | print(a+i)
32 |
--------------------------------------------------------------------------------
/hamlpy/test/templates/filters.html:
--------------------------------------------------------------------------------
1 | <"&'>
2 |
10 |
17 |
23 |
30 |
37 |
43 | 1
44 | 2
45 | 3
46 | 4
47 | 5
48 |
49 |
--------------------------------------------------------------------------------
/hamlpy/test/templates/filtersMarkdown.hamlpy:
--------------------------------------------------------------------------------
1 | :markdown
2 | hello
3 | no paragraph
4 |
5 | line break
6 | follow
7 |
8 | New paragraph
9 |
10 | code block
11 |
--------------------------------------------------------------------------------
/hamlpy/test/templates/filtersMarkdown.html:
--------------------------------------------------------------------------------
1 | hello 2 | no paragraph
3 |line break
4 | follow
New paragraph
6 |code block
7 | print "hi"
2 |
3 | if x:
4 | print "y":
5 | else:
6 | print "z":
7 |
2 |
7 |
3 | This will
4 |
5 | More
6 | Hello
8 |
--------------------------------------------------------------------------------
/hamlpy/test/templates/implicitDivs.hamlpy:
--------------------------------------------------------------------------------
1 | .articles
2 | #article_1
3 | .title.bold So happy
4 | #content_1.content
5 | Finally, I can use HAML again!
--------------------------------------------------------------------------------
/hamlpy/test/templates/implicitDivs.html:
--------------------------------------------------------------------------------
1 |
2 |
9 |
--------------------------------------------------------------------------------
/hamlpy/test/templates/multiLineDict.hamlpy:
--------------------------------------------------------------------------------
1 | %div{'class': 'row'}
2 | %img{'src': '/static/imgs/ibl_logo{{id}}.gif',
3 | 'alt': 'IBL Logo'}
4 | %br
5 | %img(src='/static/imgs/ibl_logo.gif'
6 | alt = 'IBL Logo{{id}}')
--------------------------------------------------------------------------------
/hamlpy/test/templates/multiLineDict.html:
--------------------------------------------------------------------------------
1 |
3 |
8 | So happy
4 |
5 | Finally, I can use HAML again!
6 |
7 |
2 | 
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/hamlpy/test/templates/nestedComments.hamlpy:
--------------------------------------------------------------------------------
1 | /
2 | %div.someClass
3 | %div
4 | None of this matters
--------------------------------------------------------------------------------
/hamlpy/test/templates/nestedComments.html:
--------------------------------------------------------------------------------
1 |
8 |
--------------------------------------------------------------------------------
/hamlpy/test/templates/nestedDjangoTags.hamlpy:
--------------------------------------------------------------------------------
1 | %ul
2 | - for story in story_list
3 | %li= story.text
4 | - if story.author_list
5 | - for author in story.author_list
6 | .author= author
7 | - else
8 | .author Anonymous
9 | - empty
10 | .error No stories found
--------------------------------------------------------------------------------
/hamlpy/test/templates/nestedDjangoTags.html:
--------------------------------------------------------------------------------
1 |
3 | 4 |
5 | -
2 | {% for story in story_list %}
3 |
- {{ story.text }} 4 | {% if story.author_list %} 5 | {% for author in story.author_list %} 6 | 7 | {% endfor %} 8 | {% else %} 9 | 10 | {% endif %} 11 | {% empty %} 12 |
No stories found
13 | {% endfor %}
14 | Foo
2 |{% if something %}
3 |
4 | Foo
5 |
6 | {% endif %}
{{ Foo }}
8 |
9 | Foo
10 |
12 | Foo
13 |
15 | {{ FooBar }}
16 |
18 | Foo
19 | Bar
20 |
22 | Foo
23 | Bar
24 |
26 |
30 |
27 | Foo
28 | Bar
29 |
32 |
37 |
33 | Foo
34 | Bar
35 |
36 |
39 | {{ foo }}
40 | bar
41 |
42 | bar
43 |
44 |
test1 46 | test2
47 |blah 48 | test3 49 | test4
50 |test5 51 | test6 52 | test7 53 | test8 54 | test9
55 | -------------------------------------------------------------------------------- /hamlpy/test/templates/nukeOuterWhiteSpace.hamlpy: -------------------------------------------------------------------------------- 1 | %ul#display-inline-block-example 2 | %li Item one 3 | %li> Item two 4 | %li Item three 5 | %p 6 | - if something 7 | %q> 8 | Foo 9 | %p 10 | - sometag 11 | %q> 12 | Foo 13 | %p 14 | /[test] 15 | %q> 16 | Foo 17 | %p 18 | :javascript 19 | test 20 | %q> 21 | blah 22 | -# Tests from Ruby HAML 23 | %p 24 | %p 25 | %q> 26 | Foo 27 | %p 28 | %p 29 | %q{a: '2'}> 30 | Foo 31 | %p 32 | %p 33 | %q> Foo 34 | %p 35 | %p 36 | %q{a: "2"}> Foo 37 | %p 38 | %p 39 | %q> 40 | = Foo 41 | %p 42 | %p 43 | %q{a: "2"}> 44 | = Foo 45 | %p 46 | %p 47 | %q>= Foo 48 | %p 49 | %p 50 | %q{a: "2"}>= Foo 51 | %p 52 | %p 53 | foo 54 | %q> 55 | Foo 56 | bar 57 | %p 58 | %p 59 | foo 60 | %q{a: 2}> 61 | Foo 62 | bar 63 | %p 64 | %p 65 | foo 66 | %q> Foo 67 | bar 68 | %p 69 | %p 70 | foo 71 | %q{a: "2"}> Foo 72 | bar 73 | %p 74 | %p 75 | foo 76 | %q> 77 | = Foo 78 | bar 79 | %p 80 | %p 81 | foo 82 | %q{a: "2"}> 83 | = Foo 84 | bar 85 | %p 86 | %p 87 | foo 88 | %q>= Foo 89 | bar 90 | %p 91 | %p 92 | foo 93 | %q{a: "2"}>= Foo 94 | bar 95 | %p 96 | %p 97 | foo 98 | %q> 99 | = FooBar 100 | bar 101 | %p 102 | %p 103 | foo 104 | %q{a: "2"}> 105 | = FooBar 106 | bar 107 | %p 108 | %p 109 | foo 110 | %q>= FooBar 111 | bar 112 | %p 113 | %p 114 | foo 115 | %q{a: "2"}>= FooBar 116 | bar 117 | %p 118 | %p 119 | %q> 120 | %p 121 | %p 122 | %q>/ 123 | %p 124 | %p 125 | %q{a: "2"}> 126 | %p 127 | %p 128 | %q{a: "2"}>/ -------------------------------------------------------------------------------- /hamlpy/test/templates/nukeOuterWhiteSpace.html: -------------------------------------------------------------------------------- 1 |-
2 |
- Item one
- Item two
- Item three 3 |
5 | {% if something %}
6 | Foo
7 |
{% endif %}
8 |
10 | {% sometag %}
11 | Foo
12 |
14 | 17 |
18 |
19 |
24 | blah
25 |
27 |
28 | Foo
29 |
32 |
33 | Foo
34 |
37 |
Foo
40 |
Foo
43 |
44 | {{ Foo }}
45 |
48 |
49 | {{ Foo }}
50 |
53 |
{{ Foo }}
56 |
{{ Foo }}
59 |
60 | foo
61 | Foo
62 |
bar
63 |
66 |
67 | foo
68 | Foo
69 |
bar
70 |
73 |
74 | fooFoo
bar
75 |
78 |
79 | fooFoo
bar
80 |
83 |
84 | foo
85 | {{ Foo }}
86 |
bar
87 |
90 |
91 | foo
92 | {{ Foo }}
93 |
bar
94 |
97 |
98 | foo{{ Foo }}
bar
99 |
102 |
103 | foo{{ Foo }}
bar
104 |
107 |
108 | foo
109 | {{ FooBar }}
110 |
bar
111 |
114 |
115 | foo
116 | {{ FooBar }}
117 |
bar
118 |
121 |
122 | foo{{ FooBar }}
bar
123 |
126 |
127 | foo{{ FooBar }}
bar
128 |
131 |
132 | 133 |
134 |
135 | 136 |
137 |
138 | 139 |
140 |
141 | 142 | -------------------------------------------------------------------------------- /hamlpy/test/templates/selfClosingDjango.hamlpy: -------------------------------------------------------------------------------- 1 | %ul 2 | - for story in story_list 3 | %li= story.text 4 | - blocktrans with object.duration_as_time as dur 5 | %span.jtimer.bigger {{ dur }} 6 | remain 7 | -------------------------------------------------------------------------------- /hamlpy/test/templates/selfClosingDjango.html: -------------------------------------------------------------------------------- 1 |
-
2 | {% for story in story_list %}
3 |
- {{ story.text }} 4 | {% endfor %} 5 |
3 |
4 | 5 |
8 |
9 | -------------------------------------------------------------------------------- /hamlpy/test/templates/simple.hamlpy: -------------------------------------------------------------------------------- 1 | %div 2 | %ng-repeat.someClass 3 | Here we go 4 | And more 5 | %div More 6 | -------------------------------------------------------------------------------- /hamlpy/test/templates/simple.html: -------------------------------------------------------------------------------- 1 |
2 |
3 | Here we go
4 | And more
5 |
6 |
7 | More
8 |
--------------------------------------------------------------------------------
/hamlpy/test/templates/whitespacePreservation.hamlpy:
--------------------------------------------------------------------------------
1 | -# Test plaintext/elements
2 | %pre
3 |
4 |
5 | %div{class:'something'}
6 |
7 |
8 | Some text
9 |
10 | Some other text
11 |
12 |
13 | Some more text
14 |
15 |
16 | -# Test self-closing tag
17 | %input{type:'text'}
18 |
19 |
20 | -# Test inline element
21 | %div{class:'something'}= var
22 |
23 |
24 | -# Test Django tag
25 | - if something
26 |
27 | Test 1
28 |
29 | %div
30 |
31 |
32 | Test 2
33 |
34 |
35 | -# Test filters
36 | :plain
37 |
38 | Some text
39 | Some plain text
40 |
41 | Some more text
42 |
43 |
44 | One more text
45 |
46 | :css
47 |
48 | Some text
49 | Some plain text
50 |
51 | Some more text
52 |
53 |
54 | One more text
55 |
56 | :stylus
57 |
58 | Some text
59 | Some plain text
60 |
61 | Some more text
62 |
63 |
64 | One more text
65 |
66 | :cdata
67 |
68 | Some text
69 | Some plain text
70 |
71 | Some more text
72 |
73 |
74 | One more text
75 |
76 | :coffee
77 |
78 | Some text
79 | Some plain text
80 |
81 | Some more text
82 |
83 |
84 | One more text
85 |
86 | :javascript
87 |
88 | Some text
89 | Some plain text
90 |
91 | Some more text
92 |
93 |
94 | One more text
95 |
96 | -# Test inner whitespace removal
97 |
98 | %div<
99 |
100 | Test
101 |
102 | asd
103 |
104 | -# Test outer whitespace removal
105 |
106 | %p
107 |
108 | %li Item one
109 |
110 | %li> Item two
111 |
112 | %li Item three
113 |
114 | %p
115 |
116 | %li>
117 | Item one
118 |
119 | %p
120 |
121 | %li> Item one
122 |
123 |
124 | %li Item two
125 |
126 | %li Item three
127 |
128 | %input
129 | %input>
130 | %input
--------------------------------------------------------------------------------
/hamlpy/test/templates/whitespacePreservation.html:
--------------------------------------------------------------------------------
1 | 2 | 3 | 4 |17 | 18 | 19 | 20 |5 | 6 | 7 | Some text 8 | 9 | Some other text 10 | 11 | 12 | Some more text 13 | 14 | 15 |16 |
{{ var }}
21 |
22 |
23 | {% if something %}
24 |
25 | Test 1
26 |
27 |
28 |
29 |
30 | Test 2
31 |
32 |
33 |
34 | {% endif %}
35 |
36 |
37 | Some text
38 | Some plain text
39 |
40 | Some more text
41 |
42 |
43 | One more text
44 |
45 |
57 |
69 |
79 |
91 |
103 |
104 | Test
105 |
106 | asd
107 |
108 | 109 | 110 |
Some text
")
19 |
20 | # id with non-ascii characters
21 | self._test("%div#これはテストです test", "test
")
22 |
23 | # class on tag
24 | self._test("%div.someClass Some text", "Some text
")
25 |
26 | # class can contain dash
27 | self._test(".header.span-24.last", "")
28 |
29 | # multiple classes
30 | self._test("%div.someClass.anotherClass Some text", "Some text
")
31 |
32 | # class can come before id
33 | self._test("%div.someClass#someId", "")
34 |
35 | def test_attribute_dictionaries(self):
36 | # attribute dictionaries
37 | self._test(
38 | "%html{'xmlns':'http://www.w3.org/1999/xhtml', 'xml:lang':'en', 'lang':'en'}",
39 | "",
40 | )
41 |
42 | # attribute whitespace is ignored
43 | self._test('%form{ id : "myform" }', "")
44 |
45 | # HTML style
46 | self._test('%form(foo=bar id="myform")', "")
47 |
48 | # multiple dicts
49 | self._test('%a(a="b"){:c => "d"} Stuff', "Stuff")
50 |
51 | self._test_error("%a(b=)", 'Unexpected ")". @ "%a(b=)" <-')
52 |
53 | def test_boolean_attributes(self):
54 | self._test("%input{required}", "")
55 | self._test("%input{required, a: 'b'}", "")
56 | self._test("%input{a: 'b', required, b: 'c'}", "")
57 | self._test("%input{a: 'b', required}", "")
58 | self._test("%input{checked, required, visible}", "")
59 | self._test("%input(checked=true)", "")
60 | self._test("%input(checked=true)", "", options={"format": "xhtml"})
61 |
62 | def test_attribute_values_as_tuples_and_lists(self):
63 | # id attribute as tuple
64 | self._test("%div{'id':('itemType', '5')}", "")
65 |
66 | # attributes as lists
67 | self._test(
68 | "%div{'id':['Article','1'], 'class':['article','entry','visible']} Booyaka",
69 | "Booyaka
",
70 | )
71 | self._test(
72 | "%div{'id': ('article', '3'), 'class': ('newest', 'urgent')} Content",
73 | "Content
",
74 | )
75 |
76 | def test_comments(self):
77 | self._test("/ some comment", "")
78 |
79 | # comments should hide child nodes
80 | self._test(
81 | """
82 | -# My comment
83 | #my_div
84 | my text
85 | test""",
86 | "test",
87 | )
88 |
89 | # conditional comments
90 | self._test("/[if IE] You use a shitty browser", "")
91 | self._test(
92 | "/[if IE]\n %h1 You use a shitty browser",
93 | "",
94 | )
95 | self._test("/[if lte IE 7]\n\ttest\n#test", "\n")
96 |
97 | def test_django_variables(self):
98 | # whole-line variable with =
99 | self._test("= story.tease", "{{ story.tease }}")
100 |
101 | # element content variable with =
102 | self._test("%div= story.tease", "{{ story.tease }}
")
103 |
104 | # embedded Django variables using #{...}
105 | self._test("#{greeting} #{name}, how are you #{date}?", "{{ greeting }} {{ name }}, how are you {{ date }}?")
106 | self._test("%h1 Hello, #{person.name}, how are you?", "Hello, {{ person.name }}, how are you?
") 107 | 108 | # embedded Django variables using ={...} (not enabled by default) 109 | self._test("Hi ={name}, how are you?", "Hi ={name}, how are you?") 110 | self._test("Hi ={name}, how are you?", "Hi {{ name }}, how are you?", options={"django_inline_style": True}) 111 | 112 | # variables can use Django filters 113 | self._test('#{value|center:"15"}', '{{ value|center:"15" }}') 114 | 115 | # variables can be used in attribute values 116 | self._test("%a{'b': '#{greeting} test'} blah", "blah") 117 | 118 | # including in the id or class 119 | self._test("%div{'id':'package_#{object.id}'}", "") 120 | self._test("%div{'class':'package_#{object.id}'}", "") 121 | 122 | # they can be escaped 123 | self._test( 124 | "%a{'b': '\\\\#{greeting} test', title: \"It can't be removed\"} blah", 125 | "blah", 126 | ) 127 | self._test( 128 | "%h1 Hello, \\={name}, how are you ={ date }?", 129 | "Hello, ={name}, how are you {{ date }}?
", 130 | options={"django_inline_style": True}, 131 | ) 132 | self._test("\\#{name}, how are you?", "#{name}, how are you?") 133 | 134 | def test_django_tags(self): 135 | # if/else 136 | self._test( 137 | "- if something\n %p hello\n- else\n %p goodbye", 138 | "{% if something %}\nhello
\n{% else %}\ngoodbye
\n{% endif %}", 139 | ) 140 | 141 | # with 142 | self._test("- with thing1 as another\n stuff", "{% with thing1 as another %}\n stuff\n{% endwith %}") 143 | self._test( 144 | "- with context\n hello\n- with other_context\n goodbye", 145 | "{% with context %}\n hello\n{% endwith %}\n{% with other_context %}\n goodbye\n{% endwith %}", 146 | ) 147 | 148 | # block 149 | self._test( 150 | "-block title\n %p hello\n", 151 | "{% block title %}\nhello
\n{% endblock %}", 152 | ) 153 | self._test( 154 | "-block title\n %p hello\n", 155 | "{% block title %}\nhello
\n{% endblock title %}", 156 | options={"endblock_names": True}, 157 | ) 158 | 159 | # trans 160 | self._test('- trans "Hello"\n', '{% trans "Hello" %}') 161 | 162 | # blocktrans 163 | self._test( 164 | "- blocktrans with amount=num_cookies\n" " There are #{ amount } cookies", 165 | "{% blocktrans with amount=num_cookies %}\n" " There are {{ amount }} cookies\n" "{% endblocktrans %}", 166 | ) 167 | self._test( 168 | "- blocktrans with amount=num_cookies\n" 169 | " There is one cookie\n" 170 | "- plural\n" 171 | " There are #{ amount } cookies", 172 | "{% blocktrans with amount=num_cookies %}\n" 173 | " There is one cookie\n" 174 | "{% plural %}\n" 175 | " There are {{ amount }} cookies\n" 176 | "{% endblocktrans %}", 177 | ) 178 | 179 | # exception using a closing tag of a self-closing tag 180 | parser = Compiler() 181 | self.assertRaises(ParseException, parser.process, "- endfor") 182 | 183 | def test_plain_text(self): 184 | self._test("This should be plain text", "This should be plain text") 185 | self._test( 186 | "This should be plain text\n This should be indented", 187 | "This should be plain text\n This should be indented", 188 | ) 189 | 190 | # native Django tags {% %} should be treated as plain text 191 | self._test("text {%\n trans ''\n%}", "text {%\n trans ''\n%}") 192 | self._test("text\n {%\n trans ''\n%}", "text\n {%\n trans ''\n%}") 193 | 194 | def test_plain_filter(self): 195 | # with indentation 196 | self._test( 197 | ":plain\n -This should be plain text\n .This should be more\n This should be indented", 198 | "-This should be plain text\n.This should be more\n This should be indented", 199 | ) 200 | 201 | # with no children 202 | self._test(":plain\nNothing", "Nothing") 203 | 204 | # with escaped back slash 205 | self._test(":plain\n \\Something", "\\Something") 206 | 207 | # with space after filter name 208 | self._test(":plain \n -This should be plain text\n", "-This should be plain text") 209 | 210 | def test_preserve_filter(self): 211 | # with indentation 212 | self._test( 213 | ":preserve\n -This should be plain text\n .This should be more\n This should be indented", 214 | "-This should be plain text .This should be more This should be indented", 215 | ) 216 | 217 | # with no children 218 | self._test(":preserve\nNothing", "Nothing") 219 | 220 | # with escaped back slash 221 | self._test(":preserve\n \\Something", "\\Something") 222 | 223 | def test_python_filter(self): 224 | self._test(":python\n", "") # empty 225 | self._test( 226 | ':python\n for i in range(0, 5): print("item \\%s
" % i)', 227 | "item \\0
\nitem \\1
\nitem \\2
\nitem \\3
\nitem \\4
", 228 | ) 229 | 230 | self._test_error(":python\n print(10 / 0)", "Error whilst executing python filter node", ZeroDivisionError) 231 | 232 | def test_pygments_filter(self): 233 | self._test(":highlight\n", "") # empty 234 | self._test( 235 | ":highlight\n print(1)\n", 'print(1)\nTitle
") 247 | 248 | filters._markdown_available = False 249 | 250 | self._test_error(":markdown\n *Title*\n", "Markdown is not available") 251 | 252 | filters._markdown_available = True 253 | 254 | def test_invalid_filter(self): 255 | self._test_error(":nosuchfilter\n", "No such filter: nosuchfilter") 256 | 257 | def test_doctypes(self): 258 | self._test("!!!", "", options={"format": "html5"}) 259 | self._test("!!! 5", "", options={"format": "xhtml"}) 260 | self._test("!!! 5", "") 261 | self._test( 262 | "!!! strict", 263 | '', # noqa 264 | options={"format": "xhtml"}, 265 | ) 266 | self._test( 267 | "!!! frameset", 268 | '', # noqa 269 | options={"format": "xhtml"}, 270 | ) 271 | self._test( 272 | "!!! mobile", 273 | '', # noqa 274 | options={"format": "xhtml"}, 275 | ) 276 | self._test( 277 | "!!! basic", 278 | '', # noqa 279 | options={"format": "xhtml"}, 280 | ) 281 | self._test( 282 | "!!! transitional", 283 | '', # noqa 284 | options={"format": "xhtml"}, 285 | ) 286 | self._test( 287 | "!!!", 288 | '', # noqa 289 | options={"format": "xhtml"}, 290 | ) 291 | self._test( 292 | "!!! strict", 293 | '', # noqa 294 | options={"format": "html4"}, 295 | ) 296 | self._test( 297 | "!!! frameset", 298 | '', # noqa 299 | options={"format": "html4"}, 300 | ) 301 | self._test( 302 | "!!! transitional", 303 | '', # noqa 304 | options={"format": "html4"}, 305 | ) 306 | self._test( 307 | "!!!", 308 | '', # noqa 309 | options={"format": "html4"}, 310 | ) 311 | 312 | self._test("!!! XML", "", options={"format": "html4"}) 313 | self._test("!!! XML iso-8589", "", options={"format": "xhtml"}) 314 | 315 | def test_attr_wrapper(self): 316 | self._test( 317 | "%p{ :strange => 'attrs'}", "", options={"attr_wrapper": "*", "escape_attrs": True} 318 | ) 319 | self._test( 320 | "%p{ :escaped => 'quo\"te'}", 321 | '', 322 | options={"attr_wrapper": '"', "escape_attrs": True}, 323 | ) 324 | self._test( 325 | "%p{ :escaped => 'quo\\'te'}", 326 | '', 327 | options={"attr_wrapper": '"', "escape_attrs": True}, 328 | ) 329 | self._test( 330 | "%p{ :escaped => 'q\\'uo\"te'}", 331 | '', 332 | options={"attr_wrapper": '"', "escape_attrs": True}, 333 | ) 334 | self._test( 335 | "!!! XML", 336 | '', 337 | options={"attr_wrapper": '"', "format": "xhtml", "escape_attrs": True}, 338 | ) 339 | 340 | # smart quotes... 341 | 342 | self._test( 343 | """%a(onclick="alert('hi')")""", 344 | """""", 345 | options={"attr_wrapper": '"', "smart_quotes": False}, 346 | ) 347 | self._test( 348 | """%a(onclick="alert('hi')")""", 349 | """""", 350 | options={"attr_wrapper": '"', "smart_quotes": True}, 351 | ) 352 | self._test( 353 | """%a(onclick="alert('hi')")""", 354 | """""", 355 | options={"attr_wrapper": "'", "smart_quotes": True}, 356 | ) 357 | self._test( 358 | """%a(onclick='alert("hi {% trans "world" %}")')""", 359 | """""", 360 | options={"attr_wrapper": '"', "smart_quotes": True}, 361 | ) 362 | 363 | def test_attr_escaping(self): 364 | self._test( 365 | """#foo{:class => ''}""", 366 | """""", 367 | options={"escape_attrs": False}, 368 | ) 369 | self._test( 370 | """#foo{:class => '"<>&"'}""", 371 | """""", 372 | options={"escape_attrs": True}, 373 | ) 374 | self._test( 375 | """#foo{:class => '{% trans "Hello" %}'}""", 376 | """""", 377 | options={"escape_attrs": True}, 378 | ) 379 | 380 | def test_node_escaping(self): 381 | self._test("\\= Escaped", "= Escaped") 382 | self._test("\\%}", "%}") 383 | self._test(" \\:python", " :python") 384 | 385 | def test_utf8(self): 386 | self._test( 387 | "%a{'href':'', 'title':'링크(Korean)'} Some Link", "Some Link" 388 | ) 389 | 390 | def test_custom_filter(self): 391 | def upper(text, options): 392 | return text.upper() 393 | 394 | filters.register_filter("upper", upper) 395 | 396 | self._test(":upper\n welcome", "WELCOME") 397 | 398 | def _test(self, haml, expected_html, options=None): 399 | if not options: 400 | options = {"escape_attrs": True} 401 | 402 | compiler = Compiler(options) 403 | result = compiler.process(haml) 404 | 405 | result = result.rstrip("\n") # ignore trailing new lines 406 | 407 | assert result == expected_html 408 | 409 | def _test_error(self, haml, expected_message, expected_cause=None, compiler_options=None): 410 | compiler = Compiler(compiler_options) 411 | 412 | try: 413 | compiler.process(haml) 414 | self.fail("Expected exception to be raised") 415 | except Exception as e: 416 | self.assertIsInstance(e, ParseException) 417 | assert str(e) == expected_message 418 | 419 | if expected_cause: 420 | assert type(e.__cause__) == expected_cause 421 | -------------------------------------------------------------------------------- /hamlpy/test/test_elements.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | from collections import OrderedDict 3 | 4 | from hamlpy.compiler import Compiler 5 | from hamlpy.parser.core import Stream 6 | from hamlpy.parser.elements import Element, read_element, read_tag 7 | 8 | 9 | class ElementTest(unittest.TestCase): 10 | def test_read_tag(self): 11 | stream = Stream("angular:ng-repeat(") 12 | self.assertEqual(read_tag(stream), "angular:ng-repeat") 13 | self.assertEqual(stream.text[stream.ptr :], "(") 14 | 15 | def test_read_element(self): 16 | stream = Stream('%angular:ng-repeat.my-class.other:class#my-id(class="test")>Hello\n" 13 | assert extension.preprocess("%span Hello", "test.hamlpy") == "Hello\n" 14 | assert extension.preprocess("%span Hello", "../templates/test.hamlpy") == "Hello\n" 15 | 16 | # non-Haml extension should be ignored 17 | assert extension.preprocess("%span Hello", "test.txt") == "%span Hello" 18 | 19 | # exceptions converted to Jinja2 exceptions 20 | self.assertRaisesRegex( 21 | TemplateSyntaxError, 22 | r'Unterminated string \(expected "\). @ "%span{"}"', 23 | extension.preprocess, 24 | '%span{"}', 25 | "test.haml", 26 | ) 27 | -------------------------------------------------------------------------------- /hamlpy/test/test_loader.py: -------------------------------------------------------------------------------- 1 | import importlib 2 | from unittest import mock 3 | 4 | import pytest 5 | 6 | from django.template import TemplateDoesNotExist 7 | from django.template.loader import render_to_string 8 | from django.test import SimpleTestCase 9 | from django.test.utils import override_settings 10 | 11 | from hamlpy.compiler import Compiler 12 | from hamlpy.template import loaders 13 | 14 | 15 | class LoaderTest(SimpleTestCase): 16 | def setUp(self): 17 | super(LoaderTest, self).setUp() 18 | 19 | importlib.reload(loaders) 20 | 21 | @mock.patch("hamlpy.template.loaders.Compiler", wraps=Compiler) 22 | def test_compiler_default_settings(self, mock_compiler_class): 23 | render_to_string("simple.hamlpy") 24 | 25 | mock_compiler_class.assert_called_once_with(options={}) 26 | mock_compiler_class.reset_mock() 27 | 28 | @override_settings(HAMLPY_ATTR_WRAPPER='"', HAMLPY_DJANGO_INLINE_STYLE=False) 29 | def test_compiler_settings(self): 30 | importlib.reload(loaders) 31 | 32 | with mock.patch("hamlpy.template.loaders.Compiler", wraps=Compiler) as mock_compiler_class: 33 | rendered = render_to_string("simple.hamlpy") 34 | 35 | mock_compiler_class.assert_called_once_with(options={"attr_wrapper": '"', "django_inline_style": False}) 36 | 37 | assert '"someClass"' in rendered 38 | 39 | def test_template_rendering(self): 40 | assert render_to_string("simple.hamlpy") == self._load_test_template("simple.html") 41 | 42 | context = { 43 | "section": {"title": "News", "subtitle": "Technology"}, 44 | "story_list": [ 45 | { 46 | "headline": "Haml Helps", 47 | "tease": "Many HAML users...", 48 | "get_absolute_url": lambda: "http://example.com/stories/1/", 49 | } 50 | ], 51 | } 52 | 53 | rendered = render_to_string("djangoCombo.hamlpy", context) 54 | 55 | assert "Technology
" in rendered 56 | assert "HAML HELPS" in rendered 57 | assert "" in rendered 58 | assert "Many HAML users...
" 59 | 60 | def test_should_ignore_non_haml_templates(self): 61 | assert render_to_string("simple.html") == self._load_test_template("simple.html") 62 | 63 | def test_should_raise_exception_when_template_doesnt_exist(self): 64 | with pytest.raises(TemplateDoesNotExist): 65 | render_to_string("simple.xyz") 66 | 67 | def _load_test_template(self, name): 68 | return open("hamlpy/test/templates/" + name, "r").read() 69 | -------------------------------------------------------------------------------- /hamlpy/test/test_nodes.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | 3 | from hamlpy.compiler import Compiler 4 | from hamlpy.parser import nodes 5 | from hamlpy.parser.core import Stream 6 | from hamlpy.parser.nodes import read_filter_node, read_node 7 | 8 | 9 | class NodeTest(unittest.TestCase): 10 | def test_read_node(self): 11 | assert isinstance(self._read_node("%div"), nodes.ElementNode) 12 | assert isinstance(self._read_node(" %html"), nodes.ElementNode) 13 | assert isinstance(self._read_node(".className"), nodes.ElementNode) 14 | assert isinstance(self._read_node(" .className"), nodes.ElementNode) 15 | assert isinstance(self._read_node("#idName"), nodes.ElementNode) 16 | assert isinstance(self._read_node(" #idName"), nodes.ElementNode) 17 | assert isinstance(self._read_node("/ some Comment"), nodes.CommentNode) 18 | assert isinstance(self._read_node(" / some Comment"), nodes.CommentNode) 19 | assert isinstance(self._read_node("just some random text"), nodes.PlaintextNode) 20 | assert isinstance(self._read_node(" more random text"), nodes.PlaintextNode) 21 | assert isinstance(self._read_node("-# This is a haml comment"), nodes.HamlCommentNode) 22 | assert isinstance(self._read_node("= some.variable"), nodes.VariableNode) 23 | assert isinstance(self._read_node("- for something in somethings"), nodes.TagNode) 24 | assert isinstance(self._read_node("\\= some.variable"), nodes.PlaintextNode) 25 | assert isinstance(self._read_node(" \\= some.variable"), nodes.PlaintextNode) 26 | assert isinstance(self._read_node("/[if IE 5]"), nodes.ConditionalCommentNode) 27 | assert isinstance(self._read_node(":plain"), nodes.FilterNode) 28 | assert isinstance(self._read_node(" :css\n"), nodes.FilterNode) 29 | assert isinstance(self._read_node(":stylus"), nodes.FilterNode) 30 | assert isinstance(self._read_node(":javascript"), nodes.FilterNode) 31 | assert isinstance(self._read_node(":coffee"), nodes.FilterNode) 32 | 33 | def test_read_filter_node(self): 34 | stream = Stream(':python\n print("hello")\n') 35 | node = read_filter_node(stream, "", Compiler()) 36 | assert node.filter_name == "python" 37 | assert node.content == ' print("hello")' 38 | assert stream.text[stream.ptr :] == "" 39 | 40 | stream = Stream(":javascript\n var i = 0;\n var j = 1;\n%span") 41 | node = read_filter_node(stream, "", Compiler()) 42 | assert node.filter_name == "javascript" 43 | assert node.content == " var i = 0;\n var j = 1;" 44 | assert stream.text[stream.ptr :] == "%span" 45 | 46 | def test_calculates_indentation_properly(self): 47 | no_indentation = self._read_node("%div") 48 | assert no_indentation.indentation == 0 49 | 50 | three_indentation = self._read_node(" %div") 51 | assert three_indentation.indentation == 3 52 | 53 | six_indentation = self._read_node(" %div") 54 | assert six_indentation.indentation == 6 55 | 56 | def test_indents_tabs_properly(self): 57 | no_indentation = self._read_node("%div") 58 | assert no_indentation.indent == "" 59 | 60 | one_tab = self._read_node(" %div") 61 | assert one_tab.indent == "\t" 62 | 63 | one_space = self._read_node(" %div") 64 | assert one_space.indent == " " 65 | 66 | three_tabs = self._read_node(" %div") 67 | assert three_tabs.indent == "\t\t\t" 68 | 69 | tab_space = self._read_node(" %div") 70 | assert tab_space.indent == "\t\t" 71 | 72 | space_tab = self._read_node(" %div") 73 | assert space_tab.indent == " " 74 | 75 | def test_lines_are_always_stripped_of_whitespace(self): 76 | some_space = self._read_node(" text") 77 | assert some_space.haml == "text" 78 | 79 | lots_of_space = self._read_node(" text ") 80 | assert lots_of_space.haml == "text" 81 | 82 | def test_inserts_nodes_into_proper_tree_depth(self): 83 | no_indentation_node = self._read_node("%div") 84 | one_indentation_node = self._read_node(" %div") 85 | two_indentation_node = self._read_node(" %div") 86 | another_one_indentation_node = self._read_node(" %div") 87 | 88 | no_indentation_node.add_node(one_indentation_node) 89 | no_indentation_node.add_node(two_indentation_node) 90 | no_indentation_node.add_node(another_one_indentation_node) 91 | 92 | assert one_indentation_node == no_indentation_node.children[0] 93 | assert two_indentation_node == no_indentation_node.children[0].children[0] 94 | assert another_one_indentation_node == no_indentation_node.children[1] 95 | 96 | def test_adds_multiple_nodes_to_one(self): 97 | start = self._read_node("%div") 98 | one = self._read_node(" %div") 99 | two = self._read_node(" %div") 100 | three = self._read_node(" %div") 101 | 102 | start.add_node(one) 103 | start.add_node(two) 104 | start.add_node(three) 105 | 106 | assert len(start.children) == 3 107 | 108 | @staticmethod 109 | def _read_node(haml): 110 | return read_node(Stream(haml), None, Compiler()) 111 | -------------------------------------------------------------------------------- /hamlpy/test/test_parser.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | 3 | from hamlpy.parser.core import ( 4 | ParseException, 5 | Stream, 6 | peek_indentation, 7 | read_line, 8 | read_number, 9 | read_quoted_string, 10 | read_symbol, 11 | read_whitespace, 12 | read_word, 13 | ) 14 | from hamlpy.parser.utils import html_escape 15 | 16 | 17 | class ParserTest(unittest.TestCase): 18 | def test_read_whitespace(self): 19 | stream = Stream(" \t foo \n bar ") 20 | 21 | assert read_whitespace(stream) == " \t " 22 | assert stream.text[stream.ptr :] == "foo \n bar " 23 | 24 | stream.ptr += 3 # skip over foo 25 | 26 | assert read_whitespace(stream) == " " 27 | assert stream.text[stream.ptr :] == "\n bar " 28 | 29 | assert read_whitespace(stream, include_newlines=True) == "\n " 30 | assert stream.text[stream.ptr :] == "bar " 31 | 32 | stream.ptr += 3 # skip over bar 33 | 34 | assert read_whitespace(stream) == " " 35 | assert stream.text[stream.ptr :] == "" 36 | 37 | def test_peek_indentation(self): 38 | assert peek_indentation(Stream("content")) == 0 39 | assert peek_indentation(Stream(" content")) == 2 40 | assert peek_indentation(Stream("\n")) is None 41 | assert peek_indentation(Stream(" \n")) is None 42 | 43 | def test_quoted_string(self): 44 | stream = Stream("'hello'---") 45 | assert read_quoted_string(stream) == "hello" 46 | assert stream.text[stream.ptr :] == "---" 47 | 48 | stream = Stream('"this don\'t \\"x\\" hmm" not in string') 49 | assert read_quoted_string(stream) == 'this don\'t "x" hmm' 50 | assert stream.text[stream.ptr :] == " not in string" 51 | 52 | self.assertRaises(ParseException, read_quoted_string, Stream('"no end quote...')) 53 | 54 | def test_read_line(self): 55 | stream = Stream("line1\n line2\n\nline4\n\n") 56 | assert read_line(stream) == "line1" 57 | assert read_line(stream) == " line2" 58 | assert read_line(stream) == "" 59 | assert read_line(stream) == "line4" 60 | assert read_line(stream) == "" 61 | assert read_line(stream) is None 62 | 63 | assert read_line(Stream("last line ")) == "last line " 64 | 65 | def test_read_number(self): 66 | stream = Stream('123"') 67 | assert read_number(stream) == "123" 68 | assert stream.text[stream.ptr :] == '"' 69 | 70 | stream = Stream("123.4xx") 71 | assert read_number(stream) == "123.4" 72 | assert stream.text[stream.ptr :] == "xx" 73 | 74 | stream = Stream("0.0001 ") 75 | assert read_number(stream) == "0.0001" 76 | assert stream.text[stream.ptr :] == " " 77 | 78 | def test_read_symbol(self): 79 | stream = Stream("=> bar") 80 | assert read_symbol(stream, ["=>", ":"]) == "=>" 81 | assert stream.text[stream.ptr :] == " bar" 82 | 83 | self.assertRaises(ParseException, read_symbol, Stream("foo"), ["=>"]) 84 | 85 | def test_read_word(self): 86 | stream = Stream("foo_bar") 87 | assert read_word(stream) == "foo_bar" 88 | assert stream.text[stream.ptr :] == "" 89 | 90 | stream = Stream("foo_bar ") 91 | assert read_word(stream) == "foo_bar" 92 | assert stream.text[stream.ptr :] == " " 93 | 94 | stream = Stream("ng-repeat(") 95 | assert read_word(stream) == "ng" 96 | assert stream.text[stream.ptr :] == "-repeat(" 97 | 98 | stream = Stream("ng-repeat(") 99 | assert read_word(stream, ("-",)) == "ng-repeat" 100 | assert stream.text[stream.ptr :] == "(" 101 | 102 | stream = Stream("これはテストです...") 103 | assert read_word(stream) == "これはテストです" 104 | assert stream.text[stream.ptr :] == "..." 105 | 106 | 107 | class UtilsTest(unittest.TestCase): 108 | def test_html_escape(self): 109 | assert html_escape("") == "" 110 | assert html_escape("&<>\"'") == "&<>"'" 111 | assert html_escape('{% trans "hello" %}') == '{% trans "hello" %}' 112 | assert html_escape('{{ foo|default:"hello" }}') == '{{ foo|default:"hello" }}' 113 | assert html_escape("{% }} & %}") == "{% }} & %}" 114 | 115 | result = html_escape('<>{% trans "hello" %}<>{{ foo|default:"hello" }}<>') 116 | assert result == '<>{% trans "hello" %}<>{{ foo|default:"hello" }}<>' 117 | -------------------------------------------------------------------------------- /hamlpy/test/test_templates.py: -------------------------------------------------------------------------------- 1 | import codecs 2 | import os 3 | import time 4 | import unittest 5 | from os import listdir, path 6 | 7 | import regex 8 | 9 | from hamlpy.compiler import Compiler 10 | 11 | TEMPLATE_DIRECTORY = "/templates/" 12 | TEMPLATE_EXTENSION = ".hamlpy" 13 | 14 | 15 | class TemplateCheck(object): 16 | compiler = Compiler(options={"format": "xhtml", "escape_attrs": True}) 17 | 18 | def __init__(self, name, haml, html): 19 | self.name = name 20 | self.haml = haml 21 | self.expected_html = html.replace("\r", "") # ignore line ending differences 22 | self.actual_html = None 23 | 24 | @classmethod 25 | def load_all(cls): 26 | directory = os.path.dirname(__file__) + TEMPLATE_DIRECTORY 27 | tests = [] 28 | 29 | # load all test files 30 | for f in listdir(directory): 31 | haml_path = path.join(directory, f) 32 | if haml_path.endswith(TEMPLATE_EXTENSION): 33 | html_path = path.splitext(haml_path)[0] + ".html" 34 | 35 | haml = codecs.open(haml_path, encoding="utf-8").read() 36 | html = open(html_path, "r").read() 37 | 38 | tests.append(TemplateCheck(haml_path, haml, html)) 39 | 40 | return tests 41 | 42 | def run(self): 43 | parsed = self.compiler.process(self.haml) 44 | 45 | # ignore line ending differences and blank lines 46 | self.actual_html = parsed.replace("\r", "") 47 | self.actual_html = regex.sub("\n[ \t]+(?=\n)", "\n", self.actual_html) 48 | 49 | def passed(self): 50 | return self.actual_html == self.expected_html 51 | 52 | 53 | class TemplateCompareTest(unittest.TestCase): 54 | def test_templates(self): 55 | tests = TemplateCheck.load_all() 56 | 57 | for test in tests: 58 | print("Template test: " + test.name) 59 | test.run() 60 | 61 | if not test.passed(): 62 | print("\nHTML (actual): ") 63 | print("\n".join(["%d. %s" % (i + 1, line) for i, line in enumerate(test.actual_html.split("\n"))])) 64 | self._print_diff(test.actual_html, test.expected_html) 65 | self.fail() 66 | 67 | @staticmethod 68 | def _print_diff(s1, s2): 69 | if len(s1) > len(s2): 70 | shorter = s2 71 | else: 72 | shorter = s1 73 | 74 | line = 1 75 | col = 1 76 | 77 | for i, _ in enumerate(shorter): 78 | if len(shorter) <= i + 1: 79 | print("Ran out of characters to compare!") 80 | print("Actual len=%d" % len(s1)) 81 | print("Expected len=%d" % len(s2)) 82 | break 83 | if s1[i] != s2[i]: 84 | print("Difference begins at line", line, "column", col) 85 | actual_line = s1.splitlines()[line - 1] 86 | expected_line = s2.splitlines()[line - 1] 87 | print("HTML (actual, len=%2d) : %s" % (len(actual_line), actual_line)) 88 | print("HTML (expected, len=%2d) : %s" % (len(expected_line), expected_line)) 89 | print("Character code (actual) : %d (%s)" % (ord(s1[i]), s1[i])) 90 | print("Character code (expected): %d (%s)" % (ord(s2[i]), s2[i])) 91 | break 92 | 93 | if shorter[i] == "\n": 94 | line += 1 95 | col = 1 96 | else: 97 | col += 1 98 | else: 99 | print("No Difference Found") 100 | 101 | 102 | def performance_test(num_runs): 103 | """ 104 | Performance test which evaluates all the testing templates a given number of times 105 | """ 106 | print("Loading all templates...") 107 | 108 | template_tests = TemplateCheck.load_all() 109 | 110 | print("Running templates tests...") 111 | 112 | times = [] 113 | 114 | for r in range(num_runs): 115 | start = time.time() 116 | 117 | for test in template_tests: 118 | test.run() 119 | 120 | times.append(time.time() - start) 121 | 122 | print( 123 | "Ran template tests %d times in %.2f seconds (average = %.3f secs)" 124 | % (num_runs, sum(times), sum(times) / float(num_runs)) 125 | ) 126 | 127 | 128 | if __name__ == "__main__": 129 | performance_test(500) 130 | -------------------------------------------------------------------------------- /hamlpy/test/test_templatize.py: -------------------------------------------------------------------------------- 1 | from django.test import SimpleTestCase 2 | 3 | 4 | class TemplatizeTest(SimpleTestCase): 5 | def test_templatize(self): 6 | from django.utils.translation import templatize 7 | 8 | # test regular Django tags 9 | output = templatize('{% trans "Foo" %}{% blocktrans %}\nBar\n{% endblocktrans %}', origin="test.html") 10 | self.assertRegex(output, r"gettext\(u?'Foo'\)") 11 | self.assertRegex(output, r"gettext\(u?'\\nBar\\n'\)") 12 | 13 | # test Haml tags with HTML origin 14 | output = templatize('- trans "Foo"\n- blocktrans\n Bar\n', origin="test.haml") 15 | self.assertRegex(output, r"gettext\(u?'Foo'\)") 16 | self.assertRegex(output, r"gettext\(u?'\\n Bar\\n'\)") 17 | 18 | # test Haml tags and HTML origin 19 | self.assertNotIn("gettext", templatize('- trans "Foo"\n- blocktrans\n Bar\n', origin="test.html")) 20 | 21 | # test Haml tags and no origin 22 | self.assertNotIn("gettext", templatize('- trans "Foo"\n- blocktrans\n Bar\n')) 23 | -------------------------------------------------------------------------------- /hamlpy/test/test_views.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | 3 | from hamlpy.views.generic import CreateView, DetailView, UpdateView 4 | 5 | 6 | class DummyCreateView(CreateView): 7 | template_name = "create.html" 8 | 9 | 10 | class DummyDetailView(DetailView): 11 | template_name = "detail.htm" 12 | 13 | 14 | class DummyUpdateView(UpdateView): 15 | template_name = "update.xml" 16 | 17 | 18 | class DjangoViewsTest(unittest.TestCase): 19 | def test_get_template_names(self): 20 | assert DummyCreateView().get_template_names() == ["create.haml", "create.hamlpy", "create.html"] 21 | assert DummyDetailView().get_template_names() == ["detail.haml", "detail.hamlpy", "detail.htm"] 22 | assert DummyUpdateView().get_template_names() == ["update.haml", "update.hamlpy", "update.xml"] 23 | -------------------------------------------------------------------------------- /hamlpy/test/test_watcher.py: -------------------------------------------------------------------------------- 1 | import os 2 | import shutil 3 | import sys 4 | import time 5 | import unittest 6 | from unittest.mock import patch 7 | 8 | from hamlpy.hamlpy_watcher import watch_folder 9 | 10 | WORKING_DIR = ".watcher_test" 11 | INPUT_DIR = WORKING_DIR + os.sep + "input" 12 | OUTPUT_DIR = WORKING_DIR + os.sep + "output" 13 | 14 | 15 | class ScriptExit(Exception): 16 | def __init__(self, exit_code): 17 | self.exit_code = exit_code 18 | 19 | 20 | class WatcherTest(unittest.TestCase): 21 | def test_watch_folder(self): 22 | # remove working directory if it exists and re-create it 23 | if os.path.exists(WORKING_DIR): 24 | shutil.rmtree(WORKING_DIR) 25 | 26 | os.makedirs(INPUT_DIR) 27 | 28 | # create some haml files for testing 29 | self._write_file(INPUT_DIR + os.sep + "test.haml", "%span{'class': 'test'}\n- shoutout\n") 30 | self._write_file(INPUT_DIR + os.sep + "error.haml", "%div{") 31 | self._write_file(INPUT_DIR + os.sep + ".#test.haml", "%hr") # will be ignored 32 | 33 | # run as once off pass - should return 1 for number of failed conversions 34 | self._run_script( 35 | [ 36 | "hamlpy_watcher.py", 37 | INPUT_DIR, 38 | OUTPUT_DIR, 39 | "--once", 40 | "--input-extension=haml", 41 | "--verbose", 42 | "--tag=shoutout:endshoutout", 43 | "--django-inline", 44 | "--jinja", 45 | ], 46 | 1, 47 | ) 48 | 49 | # check file without errors was converted 50 | self.assertFileContents( 51 | OUTPUT_DIR + os.sep + "test.html", "\n{% shoutout %}\n{% endshoutout %}\n" 52 | ) 53 | 54 | # check .#test.haml was ignored 55 | assert not os.path.exists(OUTPUT_DIR + os.sep + ".#test.html") 56 | 57 | # run without output directory which should make it default to re-using the input directory 58 | self._run_script(["hamlpy_watcher.py", INPUT_DIR, "--once", "--tag=shoutout:endshoutout"], 1) 59 | 60 | self.assertFileContents( 61 | INPUT_DIR + os.sep + "test.html", "\n{% shoutout %}\n{% endshoutout %}\n" 62 | ) 63 | 64 | # fix file with error 65 | self._write_file(INPUT_DIR + os.sep + "error.haml", "%div{}") 66 | 67 | # check exit code is zero 68 | self._run_script(["hamlpy_watcher.py", INPUT_DIR, OUTPUT_DIR, "--once"], 0) 69 | 70 | # run in watch mode with 1 second refresh 71 | self._run_script( 72 | ["hamlpy_watcher.py", INPUT_DIR, "--refresh=1", "--input-extension=haml", "--tag=shoutout:endshoutout"], 1 73 | ) 74 | 75 | def assertFileContents(self, path, contents): 76 | with open(path, "r") as f: 77 | self.assertEqual(f.read(), contents) 78 | 79 | def _write_file(self, path, text): 80 | with open(path, "w") as f: 81 | f.write(text) 82 | 83 | def _run_script(self, script_args, expected_exit_code): 84 | def raise_exception_with_code(code): 85 | raise ScriptExit(code) 86 | 87 | # patch sys.exit so it throws an exception so we can return execution to this test 88 | # patch sys.argv to pass our arguments to the script 89 | # patch time.sleep to be interrupted 90 | with patch.object(sys, "exit", side_effect=raise_exception_with_code), patch.object( 91 | sys, "argv", script_args 92 | ), patch.object(time, "sleep", side_effect=KeyboardInterrupt), self.assertRaises( 93 | ScriptExit 94 | ) as raises: # noqa 95 | watch_folder() 96 | 97 | assert raises.exception.exit_code == expected_exit_code 98 | -------------------------------------------------------------------------------- /hamlpy/views/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nyaruka/django-hamlpy/59e87ee4fceb84adeabef8358a95572544683c7a/hamlpy/views/__init__.py -------------------------------------------------------------------------------- /hamlpy/views/generic/__init__.py: -------------------------------------------------------------------------------- 1 | import django.views.generic 2 | 3 | from hamlpy import HAML_EXTENSIONS 4 | 5 | pouet = [ 6 | "ArchiveIndexView", 7 | "YearArchiveView", 8 | "MonthArchiveView", 9 | "WeekArchiveView", 10 | "DayArchiveView", 11 | "TodayArchiveView", 12 | "DateDetailView", 13 | "DetailView", 14 | "CreateView", 15 | "UpdateView", 16 | "DeleteView", 17 | "ListView", 18 | ] 19 | 20 | NON_HAML_EXTENSIONS = ("html", "htm", "xml") 21 | 22 | 23 | class HamlExtensionTemplateView(object): 24 | def get_template_names(self): 25 | names = super(HamlExtensionTemplateView, self).get_template_names() 26 | 27 | haml_names = [] 28 | 29 | for name in names: 30 | for ext in NON_HAML_EXTENSIONS: 31 | if name.endswith("." + ext): 32 | base_name = name[: -len(ext)] 33 | 34 | for haml_ext in HAML_EXTENSIONS: 35 | haml_names.append(base_name + haml_ext) 36 | 37 | return haml_names + names 38 | 39 | 40 | for view in pouet: 41 | locals()[view] = type(str(view), (HamlExtensionTemplateView, getattr(django.views.generic, view)), {}) 42 | -------------------------------------------------------------------------------- /pyproject.toml: -------------------------------------------------------------------------------- 1 | [tool.poetry] 2 | name = "django-hamlpy" 3 | version = "1.7.0" 4 | description = "HAML like syntax for Django templates" 5 | authors = ["Nyaruka