You could adapt that middlewear to make it only stop blank lines I'm sure.
I use it for one website and its only used in the production version, in my
settings for the dev version it doesn't include that middlewear so it
doesn't effect any front end development.

Only thing to be aware of is it messes up some tags, like <textarea> and
<code>

Dougal

---
Dougal Matthews - @d0ugal
http://www.dougalmatthews.com/




2009/3/16 Benjamin Buch <benni.b...@gmx.de>

>
> Thank you for your replies!
>
> What I essentially want to do is:
> 1: Keep the template output readable for the frontend coder I'm
> working with
> 2: Keep the templates readable for me.
>
> @Dougal:
> I think the solution you suggested is great when someone wants to keep
> the size of the rendered template to a minimum.
> But as it strips really all whitespace, all linebreaks and everything,
> the result is perfectly machine readable
> but nothing that would make my frontend coder be happy.
>
> @Tim:
> This solution would give me the desired output, but the templates get
> less readable for me this way.
>
> What I figured out:
>
> I gave the StripWhitespaceMiddleware I mentioned a try,
> and it works reasonably well.
> It just strips empty lines but keeps the indentation the tags have in
> the template,
> so you've got reasonable control over how the rendered templates look
> like.
>
> The downsides I see so far are:
> - You can't add empty lines to structure the rendered template
> - Multiline output from template variables are not indented (e.g.
> something like {{ entry.body|markdown }})
>
> I have no solution for the add-empty-line-problem,
> but I wrote a template tag that indents the output of a multiline
> variable.
> It's not perfect (it destroys all indentation that is output by
> markdown..) but it works for me:
>
> class IndentNode(Node):
>     def __init__(self, nodelist, indent_level):
>         self.indent_level = indent_level
>         self.nodelist = nodelist
>
>     def render(self, context):
>         rendered = self.nodelist.render(context)
>         lines = rendered.split('\n')
>         for i in range(len(lines)):
>             if lines[i]:
>                 lines[i] = ' ' * int(self.indent_level) +
> lines[i].strip(' ')
>         rendered = ''
>         for line in lines:
>             rendered += line + '\n'
>         return rendered
>
> def do_indent(parser, token):
>     bits = token.contents.split()
>     try:
>         indent_level = bits[1]
>     except IndexError:
>         indent_level = 0
>     nodelist = parser.parse(('endindent',))
>     parser.delete_first_token()
>     return IndentNode(nodelist, indent_level)
>
> You would use it like this:
>
> {% indent 8 %}
> {{ entry.body|markdown }}
> {% endindent %}
>
> An other solution I tried but rejected was to use Beatiful Soups
> 'prettify'-method in a middleware:
>
> class BeautifulSoupMiddleware:
>     def process_response(self, request, response):
>         new_content = BeautifulSoup(response.content).prettify()
>         response.content = new_content
>         return response
>
> But the output was a little to shaky, so I can't recommend it.
>
>
> benjamin
>
>
>
>
>
> >
>

--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"Django users" group.
To post to this group, send email to django-users@googlegroups.com
To unsubscribe from this group, send email to 
django-users+unsubscr...@googlegroups.com
For more options, visit this group at 
http://groups.google.com/group/django-users?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to