{ "info": { "author": "Autumn Valenta", "author_email": "tvalenta@pivotalenergysolutions.com", "bugtrack_url": null, "classifiers": [ "Development Status :: 5 - Production/Stable", "Environment :: Web Environment", "Framework :: Django", "License :: OSI Approved :: Apache Software License", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.7", "Topic :: Internet :: WWW/HTTP", "Topic :: Internet :: WWW/HTTP :: Dynamic Content", "Topic :: Software Development :: Libraries :: Python Modules" ], "description": "django-easytag\n==============\n\nA templatetag utility to greatly simplify the design of block-style tags\n\nEasyTag is a ``template.Node`` subclass that adds some automatic mechanisms which greatly simplify the common block-style tasks.\n\n\nYou can add methods to your subclass to handle any custom intermediate tag separators (think the ``for``/``empty``, ``if``/``else``).\n\n## Basic options\n\n### ``name``\n_**Required**_\n\nThe name of the tag as it should be registered with your templatetags library. See [Registering with the tag library](#registering-with-the-tag-library) below to see how to make use of this ``name`` attribute without having to repeat yourself.\n\n### ``end_tag``\n_boolean or str_\n\nIf ``end_tag`` is True, this tag will automatically parse to a matching ``{% end{name} %}`` tag. If ``end_tag`` is a string, it will be taken as-is for the end-block tag. It won't add the \"end\" prefix either, so pick a smart name!\n\n### ``intermediate_tags``\n_list of strings_\n\n``intermediate_tags`` is a list of strings that acts as a declaration of all possible intermediate tag names that can show up in the body of your main tag. For example, if you use ``intermediate_tags = [\"unless\"]``, you could write something like this in your templates:\n\n```html\n{% my_tag %}\n some content\n{% unless %}\n secondary content\n{% endmytag %}\n```\n\nBy default, both of these sections are parsed and rendered, but they are handed off to separate methods on your tag class for processing, allowing you to dynamically decide if or how to render the sibling branches.\n\nYou can have any number of intermediate tags, and they can appear in any order. If you would like to enforce a particular order, you'll need to add some logic to the specific handlers to verify that some other tag came first.\n\n## Setting up handlers for wrapped content\n\nThe beginning tag and intermediate tags will attempt to send their influenced template regions to methods on your tag class. These methods are effectively renderers; you should return the rendered content, whether or not you are modifying anything.\n\nThe simplest case is a pass-through tag:\n\n```python\nclass MyTag(EasyTag):\n name = \"my_tag\"\n\n def my_tag(self, context, nodelist):\n return nodelist.render(context)\n```\n\nYour ``my_tag`` tag should declare a method on itself named the same thing. This is the handler that the wrapped content is sent to. The ``context`` and ``nodelist`` parameters are required.\n\n_Note: In Django parlance, a \"nodelist\" is a collection of template pieces that all know how to render themselves, including chunks of plain text._\n\nIf you have intermediate tags defined note how the definition of \"wrapped content\" changes:\n\n```html\n\n{% my_tag %}\n some content\n{% unless %}\n secondary content\n{% endmytag %}\n```\n\nThe main ``my_tag`` method only receives everything up until the next intermediate block, and the intermediate block receives everything until the _next_ intermediate block or the end tag, and so on.\n\n## Sending parameters\n\nExactly like the built-in django [``simple_tag``](https://docs.djangoproject.com/en/dev/howto/custom-template-tags/#django.template.Library.simple_tag), EasyTag enables automatic forwarding of parameters sent to the tag to a method on your tag.\n\nYour tag's method requires ``context`` and ``nodelist``, but you can add any number of normal function arguments to its signature. This includes arguments with default values, ``*args`` and ``**kwargs`` for catch-alls. The proper errors will be raised if arguments are missing or unexpected.\n\nExample:\n\n```python\n# Handler inside of the MyTag class\ndef my_tag(self, context, nodelist, myflag=False):\n content = nodelist.render(context)\n if myflag is True:\n content = \"\" % (content,)\n return content\n```\n\n```html\n\n{# With optional var specified: #}\n{% mytag myflag=True %} Some content {% endmytag %}\n\n{# Without option var: #}\n{% mytag %} Other content {% endmytag %}\n```\n\n## Registering with the tag library\n\nSubclasses should set the ``name`` class attribute, which will be the name used in templates. This helps save you the trouble of writing a separate compiler function just to wrap it in the ``@register.tag`` decorator.\n\nRegistering the tag becomes very simple:\n\n```python\n# A little wordy, if you've named your local library object \"register\", as is recommended:\nMyTagClass.register_tag(register)\n\n# This is basically the ``register.tag`` decorator, and looks more like a normal\n# registration. +1 if you're all about vanilla and no magic.\nregister.tag(MyTagClass.name, MyTagClass.parser)\n```\n\nA simpler ``register()`` method cannot be added to EasyTag, since EasyTag won't have an active reference to your tag's specific Library instance, so it would be registered to the wrong library at runtime.\n\n## Using variables across intermediate tags\n\nSay you want to open your tag with some arguments, and the intermediate tags should be able to use those values as they are encountered.\n\nFor example, the target usage should look something like this:\n\n```html\n{% my_tag active_section=\"Second\" %}\n {% section name=\"First\" %}\n Some content\n {% section name=\"Second\" %}\n More content\n{% endmy_tag %}\n```\n\nIt's simple to save the variable on the ``my_tag`` handler (although if you're modifying stateful values after storing them, though please be sure to ready about the Django documentation about templatetag [thread safety](https://docs.djangoproject.com/en/dev/howto/custom-template-tags/#thread-safety-considerations)), and once you've got that done, it's a simple matter of inspecting the values:\n\n```python\ndef my_tag(self, context, nodelist, active_section=None):\n self.active_section = active_section\n\n # In the example template use, the nodelist was approximately empty,\n # holding only whitespace, but we should render it anyway.\n return nodelist.render(context)\n\ndef section(self, context, nodelist, name):\n wrapper = \"\"\"
%(content)
\"\"\"\n content = nodelist.render(context)\n if name == self.active_section:\n active_class = \"active\"\n else:\n active_class = \"\"\n return wrapper % {'active': active_class, 'content': content}\n```\n\nThis works because the ``my_tag`` handler is always executed first, being the opening tag handler.\n\n## Wrapping the entire tag output, appending, prefixing, etc\n\nBecause of the way your opening handler actually only handles the initial branch of template until the first intermediate tag, you can't use this particular spot as a way to wrap the entire output.\n\nInstead, you should override the built-in ``render()`` method of the tag. This method is provided by default on a ``template.Node`` object. The ``EasyTag.render()`` implementation iterates all of your branches and concatenates their output.\n\nConsequently, if you would like to wrap all of the output in some HTML, append markup to the end, etc, you should call ``super()`` to get the normal output, and then modify it as you see fit:\n\n```python\ndef render(self, context):\n content = super(MyTag, self).render(context)\n return \"
%s
\" % content\n```\n\n## Adding an end-tag handler\n\nIn some instances, you might want to think of appending extra output to the end of the tag. This is technically possible by overriding the ``render()`` method as discussed just above, but it seemed fitting to acknowledge the end tag as a handler itself.\n\nYou can optionally define a method on your tag that equals the tag's end-name, whatever you've set that up to be:\n\n```python\nclass MyTag(EasyTag):\n name = \"my_tag\"\n end_tag = True\n\n # ...\n\n def endmy_tag(self, context):\n return \"some trailing content\"\n```\n\nNote how there is no ``nodelist`` parameter in this case, since the end tag has no content that it is influencing. It is up to you to return some string content.\n\nAlso take note that the returned string is automatically sent through ``django.utils.safestring.mark_safe`` by Django when the content ultimately gets returned as a single large string from the ``render()`` method.\n\nThis strategy is helpful for allowing intermediate tags to accumulate some information but not act on it until the end of the tag.\n\n\n### Build Process:\n1. Update the `__version_info__` inside of the application. Commit and push.\n2. Tag the release with the version. `git tag -m \"Release\"; git push --tags`\n3. Build the release `rm -rf dist build *egg-info; python setup.py sdist bdist_wheel`\n4. Upload the data `twine upload dist/*`\n\n\n", "description_content_type": "", "docs_url": null, "download_url": "https://github.com/icmanage/django-easytag/archive/1.0.1.tar.gz", "downloads": { "last_day": -1, "last_month": -1, "last_week": -1 }, "home_page": "https://github.com/icmanage/django-easytag", "keywords": "django bootstrap", "license": "", "maintainer": "", "maintainer_email": "", "name": "icm-django-easytag", "package_url": "https://pypi.org/project/icm-django-easytag/", "platform": "", "project_url": "https://pypi.org/project/icm-django-easytag/", "project_urls": { "Download": "https://github.com/icmanage/django-easytag/archive/1.0.1.tar.gz", "Homepage": "https://github.com/icmanage/django-easytag" }, "release_url": "https://pypi.org/project/icm-django-easytag/1.0.1/", "requires_dist": [ "django (<2.0,>=1.7)" ], "requires_python": "", "summary": "A generic class to facilitate the creation of complex template tags.", "version": "1.0.1" }, "last_serial": 3865550, "releases": { "1.0.1": [ { "comment_text": "", "digests": { "md5": "430e561164a929da6a9d0c3c83a7c65b", "sha256": "7353330eec2bc46ff297ba56927e23b6258b976953b9706512d3ac4c711e58fb" }, "downloads": -1, "filename": "icm_django_easytag-1.0.1-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "430e561164a929da6a9d0c3c83a7c65b", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 10805, "upload_time": "2018-05-15T17:51:15", "url": "https://files.pythonhosted.org/packages/09/94/48693a8de34753853b6744cde4c7da0b552a8f3d00dbc747bc00d30cdf6b/icm_django_easytag-1.0.1-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "d53e2f3bcb5cad408ab6e07880402869", "sha256": "95c45dbb5aa38b2eaca3400d26851430f6a2699c078dc62b77e38856227b9e11" }, "downloads": -1, "filename": "icm-django-easytag-1.0.1.tar.gz", "has_sig": false, "md5_digest": "d53e2f3bcb5cad408ab6e07880402869", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 8758, "upload_time": "2018-05-15T17:51:16", "url": "https://files.pythonhosted.org/packages/dc/f7/36e07cc0cd7da18a42a770d5fb074a42608ac5ad7bd9af353946c58b139f/icm-django-easytag-1.0.1.tar.gz" } ], "1.0.1rc1": [ { "comment_text": "", "digests": { "md5": "fc859921b5a66577c6f0af7833c7e2dd", "sha256": "fbcd36f790d790e9e96eda5de5151b3c0b11ecaf6e88df2aecf9f97b01ed70b0" }, "downloads": -1, "filename": "icm_django_easytag-1.0.1rc1-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "fc859921b5a66577c6f0af7833c7e2dd", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 10847, "upload_time": "2018-05-15T17:48:24", "url": "https://files.pythonhosted.org/packages/8d/34/9498475fe58b81d797651772fe847d0e11b2a26c03e45489420512f13728/icm_django_easytag-1.0.1rc1-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "a0f419b48b2c77301da3276951e4a42a", "sha256": "ce84f0cffd13a2decb7d7fedc3fe976a46b613d9a18af5d8ec893633be66932f" }, "downloads": -1, "filename": "icm-django-easytag-1.0.1rc1.tar.gz", "has_sig": false, "md5_digest": "a0f419b48b2c77301da3276951e4a42a", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 8765, "upload_time": "2018-05-15T17:48:25", "url": "https://files.pythonhosted.org/packages/78/9b/78c7aa65a034c37edb2368a94b793939c9ed2e0799ef3a9640c76f481eee/icm-django-easytag-1.0.1rc1.tar.gz" } ] }, "urls": [ { "comment_text": "", "digests": { "md5": "430e561164a929da6a9d0c3c83a7c65b", "sha256": "7353330eec2bc46ff297ba56927e23b6258b976953b9706512d3ac4c711e58fb" }, "downloads": -1, "filename": "icm_django_easytag-1.0.1-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "430e561164a929da6a9d0c3c83a7c65b", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 10805, "upload_time": "2018-05-15T17:51:15", "url": "https://files.pythonhosted.org/packages/09/94/48693a8de34753853b6744cde4c7da0b552a8f3d00dbc747bc00d30cdf6b/icm_django_easytag-1.0.1-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "d53e2f3bcb5cad408ab6e07880402869", "sha256": "95c45dbb5aa38b2eaca3400d26851430f6a2699c078dc62b77e38856227b9e11" }, "downloads": -1, "filename": "icm-django-easytag-1.0.1.tar.gz", "has_sig": false, "md5_digest": "d53e2f3bcb5cad408ab6e07880402869", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 8758, "upload_time": "2018-05-15T17:51:16", "url": "https://files.pythonhosted.org/packages/dc/f7/36e07cc0cd7da18a42a770d5fb074a42608ac5ad7bd9af353946c58b139f/icm-django-easytag-1.0.1.tar.gz" } ] }