pax_global_header 0000666 0000000 0000000 00000000064 14161666113 0014517 g ustar 00root root 0000000 0000000 52 comment=90c6ee5ac54ef1127f2edcfac10c5ef3ab09e255
django-tagulous-1.3.3/ 0000775 0000000 0000000 00000000000 14161666113 0014626 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/.github/ 0000775 0000000 0000000 00000000000 14161666113 0016166 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/.github/workflows/ 0000775 0000000 0000000 00000000000 14161666113 0020223 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/.github/workflows/ci.yml 0000664 0000000 0000000 00000010321 14161666113 0021336 0 ustar 00root root 0000000 0000000 name: Tests
# Test Tagulous on:
# all supported Django and Python versions
# against sqlite, postgresql and mysql
on:
push:
pull_request:
jobs:
test-sqlite:
name: py-${{ matrix.python }} dj-${{ matrix.django }}
runs-on: ubuntu-latest
strategy:
matrix:
include:
# Test Python versions - Django LTS on supported Python - dj3.2, py3.6-3.9
- python: "3.6"
django: "3.2"
- python: "3.7"
django: "3.2"
- python: "3.8"
django: "3.2"
- python: "3.9"
django: "3.2"
# Test Django versions - Django supported on Python latest - dj2.2-3.3, py3.9
- python: "3.9"
django: "2.2"
- python: "3.9"
django: "3.0"
- python: "3.9"
django: "3.1"
- python: "3.9"
django: "3.2"
- python: "3.9"
django: "4.0"
steps:
- uses: actions/checkout@v2
- name: Set up Python ${{ matrix.python }}
uses: actions/setup-python@v2
with:
python-version: ${{ matrix.python }}
- name: Install dependencies
run: |
python -m pip install --upgrade pip
pip install -r requirements.test.txt
pip install "django~=${{ matrix.django }}.0"
- name: Test
run: |
pytest
- name: Upload coverage to Codecov
uses: codecov/codecov-action@v1
with:
name: ${{ matrix.python }}-${{ matrix.django }}
test-postgres:
name: py-${{ matrix.python }} dj-${{ matrix.django }} PostgreSQL
runs-on: ubuntu-latest
strategy:
matrix:
include:
# Django LTS on Python latest - dj2.2, py3.9
- python: "3.9"
django: "2.2"
# Django latest on Python latest - dj3.2, py3.9
- python: "3.9"
django: "4.0"
services:
postgres:
image: postgres:10.8
ports:
- 5432:5432
options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
steps:
- uses: actions/checkout@v2
- name: Set up Python ${{ matrix.python }}
uses: actions/setup-python@v2
with:
python-version: ${{ matrix.python }}
- name: Install dependencies
run: |
python -m pip install --upgrade pip
pip install -r requirements.test.txt
pip install psycopg2
pip install "django~=${{ matrix.django }}.0"
- name: Test
run: |
pytest
env:
DATABASE_ENGINE: postgresql
DATABASE_HOST: localhost
DATABASE_USER: postgres
DATABASE_PASSWORD: postgres
- name: Upload coverage to Codecov
uses: codecov/codecov-action@v1
with:
name: ${{ matrix.python }}-${{ matrix.django }}-postgres
test-mysql:
name: py-${{ matrix.python }} dj-${{ matrix.django }} MySQL
runs-on: ubuntu-latest
strategy:
matrix:
include:
# Django LTS on Python latest - dj2.2, py3.9
- python: "3.9"
django: "2.2"
# Django latest on Python latest - dj3.2, py3.9
- python: "3.9"
django: "4.0"
services:
mysql:
image: mysql:5.7
env:
MYSQL_ALLOW_EMPTY_PASSWORD: yes
ports:
- 3306:3306
options: --health-cmd="mysqladmin ping" --health-interval=10s --health-timeout=5s --health-retries=3
steps:
- uses: actions/checkout@v2
- name: Set up Python ${{ matrix.python }}
uses: actions/setup-python@v2
with:
python-version: ${{ matrix.python }}
- name: Install dependencies
run: |
python -m pip install --upgrade pip
pip install -r requirements.test.txt
pip install mysqlclient
pip install "django~=${{ matrix.django }}.0"
- name: Test
run: |
pytest
env:
DATABASE_ENGINE: mysql
DATABASE_HOST: 127.0.0.1
DATABASE_PORT: 3306
DATABASE_USER: root
- name: Upload coverage to Codecov
uses: codecov/codecov-action@v1
with:
name: ${{ matrix.python }}-${{ matrix.django }}-mysql
django-tagulous-1.3.3/.github/workflows/pypi.yml 0000664 0000000 0000000 00000001270 14161666113 0021727 0 ustar 00root root 0000000 0000000 name: PyPI
on:
push:
tags:
- 'v*'
jobs:
publish:
name: Build and publish to PyPI
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Set up Python 3.9
uses: actions/setup-python@v2
with:
python-version: 3.9
- name: Install dependencies
run: |
python -m pip install --upgrade pip
pip install setuptools wheel
- name: Build a binary wheel and a source tarball
run: |
python setup.py sdist bdist_wheel
- name: Publish to PyPI
if: startsWith(github.ref, 'refs/tags')
uses: pypa/gh-action-pypi-publish@master
with:
password: ${{ secrets.pypi_password }}
django-tagulous-1.3.3/.gitignore 0000664 0000000 0000000 00000000232 14161666113 0016613 0 ustar 00root root 0000000 0000000 *.pyc
django_tagulous.egg-info
.tox
.coverage*
htmlcov
docs/_*
build
dist
example/db.sqlite3
example/tagulous
tests/tagulous_tests_migration/migrations_*
django-tagulous-1.3.3/LICENSE 0000664 0000000 0000000 00000010255 14161666113 0015636 0 ustar 00root root 0000000 0000000 django-tagulous is licensed under the BSD License
=================================================
Copyright (c) 2015, Richard Terry, http://radiac.net/
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
Neither the name of the software nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Licenses for included third-party components
--------------------------------------------
jQuery
~~~~~~
Copyright jQuery Foundation and other contributors, https://jquery.org/
This software consists of voluntary contributions made by many
individuals. For exact contribution history, see the revision history
available at https://github.com/jquery/jquery
The following license applies to all parts of this software except as
documented below:
====
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
====
All files located in the node_modules and external directories are
externally maintained libraries used by this software which have their
own licenses; we recommend you read them, as their terms may differ from
the terms above.
Select2
~~~~~~~
Copyright 2014 Igor Vaynberg
Version: @@ver@@ Timestamp: @@timestamp@@
This software is licensed under the Apache License, Version 2.0 (the "Apache License") or the GNU General Public License version 2 (the "GPL License"). You may choose either license to govern your use of this software only upon the condition that you accept all of the terms of either the Apache License or the GPL License.
You may obtain a copy of the Apache License and the GPL License at:
http://www.apache.org/licenses/LICENSE-2.0
http://www.gnu.org/licenses/gpl-2.0.html
Unless required by applicable law or agreed to in writing, software distributed under the Apache License or the GPL Licesnse is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License and the GPL License for the specific language governing permissions and limitations under the Apache License and the GPL License.
django-tagulous-1.3.3/MANIFEST.in 0000664 0000000 0000000 00000000361 14161666113 0016364 0 ustar 00root root 0000000 0000000 include LICENSE tox.ini .travis.yml docs/conf.py docs/Makefile
recursive-include tagulous/static *
recursive-include tagulous/templates *
recursive-include tests *
recursive-exclude tests *.pyc
recursive-include docs *.rst
prune docs/_build
django-tagulous-1.3.3/README.rst 0000664 0000000 0000000 00000007021 14161666113 0016315 0 ustar 00root root 0000000 0000000 ===============================
Django Tagulous - Fabulous Tags
===============================
A tagging library for Django built on ForeignKey and ManyToManyField, giving
you all their normal power with a sprinkling of tagging syntactic sugar.
* Project site: http://radiac.net/projects/django-tagulous/
* Source code: https://github.com/radiac/django-tagulous
* Changelog: http://radiac.net/projects/django-tagulous/documentation/changelog/
.. image:: https://img.shields.io/pypi/v/django-tagulous.svg
:target: https://pypi.org/project/django-tagulous/
.. image:: https://github.com/radiac/django-tagulous/actions/workflows/ci.yml/badge.svg
:target: https://github.com/radiac/django-tagulous/actions/workflows/ci.yml
.. image:: https://codecov.io/gh/radiac/django-tagulous/branch/develop/graph/badge.svg?token=5VZNPABZ7E
:target: https://codecov.io/gh/radiac/django-tagulous
Features
========
* Easy to install - simple requirements, **simple syntax**, lots of options
* Based on ForeignKey and ManyToManyField, so it's **easy to query**
* **Autocomplete** support built in, if you want it
* Supports multiple independent tag fields on a single model
* Can be used as a user-customisable CharField with choices
* Supports **trees of nested tags**, for detailed categorisation
* Admin support for managing tags and tagged models
Supports Django 2.2 to 3.2, on Python 3.6 to 3.9.
See the `Documentation `_
for details of how Tagulous works; in particular:
* `Installation `_
- how to install Tagulous
* `Example Usage `_
- see examples of Tagulous in use
* `Upgrading `_ -
how to upgrade Tagulous, and see what has changed in the
`changelog `_.
* `Contributing `_
- for how to contribute to Tagulous, and the planned
`roadmap `_.
Quickstart
==========
Install with ``pip install django-tagulous``, add ``tagulous`` to Django's
``INSTALLED_APPS`` and `define the serializers`__, then start adding tag fields to your
model::
from django.db import models
from tagulous.models import SingleTagField, TagField
class Person(models.Model):
name = models.CharField(max_length=255)
title = SingleTagField(initial="Mr, Mrs, Miss, Ms")
skills = TagField()
You can now set and get them using strings, lists or querysets::
myperson = Person.objects.create(name='Bob', title='Mr', skills='run, hop')
# myperson.skills == 'run, hop'
myperson.skills = ['jump', 'kung fu']
myperson.save()
# myperson.skills == 'jump, "kung fu"'
runners = Person.objects.filter(skills='run')
Behind the scenes your tags are stored in separate models (by default), so
because the fields are based on ``ForeignKey`` and ``ManyToManyField`` more
complex queries are simple::
qs = MyRelatedModel.objects.filter(
person__skills__name__in=['run', 'jump'],
)
As well as this you also get autocompletion in public and admin forms,
automatic slug generation, unicode support, you can build tag clouds easily,
and can nest tags for more complex categorisation.
__ http://radiac.net/projects/django-tagulous/documentation/installation/
django-tagulous-1.3.3/docs/ 0000775 0000000 0000000 00000000000 14161666113 0015556 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/docs/Makefile 0000664 0000000 0000000 00000016425 14161666113 0017226 0 ustar 00root root 0000000 0000000 # Makefile for Sphinx documentation
#
# You can set these variables from the command line.
SPHINXOPTS =
SPHINXBUILD = sphinx-build
PAPER =
BUILDDIR = _build
# User-friendly check for sphinx-build
ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1)
$(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/)
endif
# Internal variables.
PAPEROPT_a4 = -D latex_paper_size=a4
PAPEROPT_letter = -D latex_paper_size=letter
ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
# the i18n builder cannot share the environment and doctrees with the others
I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest coverage gettext
help:
@echo "Please use \`make ' where is one of"
@echo " html to make standalone HTML files"
@echo " dirhtml to make HTML files named index.html in directories"
@echo " singlehtml to make a single large HTML file"
@echo " pickle to make pickle files"
@echo " json to make JSON files"
@echo " htmlhelp to make HTML files and a HTML help project"
@echo " qthelp to make HTML files and a qthelp project"
@echo " applehelp to make an Apple Help Book"
@echo " devhelp to make HTML files and a Devhelp project"
@echo " epub to make an epub"
@echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
@echo " latexpdf to make LaTeX files and run them through pdflatex"
@echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
@echo " text to make text files"
@echo " man to make manual pages"
@echo " texinfo to make Texinfo files"
@echo " info to make Texinfo files and run them through makeinfo"
@echo " gettext to make PO message catalogs"
@echo " changes to make an overview of all changed/added/deprecated items"
@echo " xml to make Docutils-native XML files"
@echo " pseudoxml to make pseudoxml-XML files for display purposes"
@echo " linkcheck to check all external links for integrity"
@echo " doctest to run all doctests embedded in the documentation (if enabled)"
@echo " coverage to run coverage check of the documentation (if enabled)"
clean:
rm -rf $(BUILDDIR)/*
html:
$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
dirhtml:
$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
singlehtml:
$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
@echo
@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
pickle:
$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
@echo
@echo "Build finished; now you can process the pickle files."
json:
$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
@echo
@echo "Build finished; now you can process the JSON files."
htmlhelp:
$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
@echo
@echo "Build finished; now you can run HTML Help Workshop with the" \
".hhp project file in $(BUILDDIR)/htmlhelp."
qthelp:
$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
@echo
@echo "Build finished; now you can run "qcollectiongenerator" with the" \
".qhcp project file in $(BUILDDIR)/qthelp, like this:"
@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/django-tagulous.qhcp"
@echo "To view the help file:"
@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/django-tagulous.qhc"
applehelp:
$(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp
@echo
@echo "Build finished. The help book is in $(BUILDDIR)/applehelp."
@echo "N.B. You won't be able to view it unless you put it in" \
"~/Library/Documentation/Help or install it in your application" \
"bundle."
devhelp:
$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
@echo
@echo "Build finished."
@echo "To view the help file:"
@echo "# mkdir -p $$HOME/.local/share/devhelp/django-tagulous"
@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/django-tagulous"
@echo "# devhelp"
epub:
$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
@echo
@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
latex:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo
@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
@echo "Run \`make' in that directory to run these through (pdf)latex" \
"(use \`make latexpdf' here to do that automatically)."
latexpdf:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo "Running LaTeX files through pdflatex..."
$(MAKE) -C $(BUILDDIR)/latex all-pdf
@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
latexpdfja:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo "Running LaTeX files through platex and dvipdfmx..."
$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
text:
$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
@echo
@echo "Build finished. The text files are in $(BUILDDIR)/text."
man:
$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
@echo
@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
texinfo:
$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
@echo
@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
@echo "Run \`make' in that directory to run these through makeinfo" \
"(use \`make info' here to do that automatically)."
info:
$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
@echo "Running Texinfo files through makeinfo..."
make -C $(BUILDDIR)/texinfo info
@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
gettext:
$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
@echo
@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
changes:
$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
@echo
@echo "The overview file is in $(BUILDDIR)/changes."
linkcheck:
$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
@echo
@echo "Link check complete; look for any errors in the above output " \
"or in $(BUILDDIR)/linkcheck/output.txt."
doctest:
$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
@echo "Testing of doctests in the sources finished, look at the " \
"results in $(BUILDDIR)/doctest/output.txt."
coverage:
$(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage
@echo "Testing of coverage in the sources finished, look at the " \
"results in $(BUILDDIR)/coverage/python.txt."
xml:
$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
@echo
@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
pseudoxml:
$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
@echo
@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
django-tagulous-1.3.3/docs/admin.rst 0000664 0000000 0000000 00000011134 14161666113 0017400 0 ustar 00root root 0000000 0000000 =====
Admin
=====
Tag fields in ModelAdmin
========================
To support TagField and SingleTagField fields in the admin, you need to
register the Model and ModelAdmin using Tagulous's ``register()`` function,
instead of the standard one::
import tagulous.admin
class MyAdmin(admin.ModelAdmin):
list_display = ['name', 'tags']
tagulous.admin.register(MyModel, MyAdmin)
This will make a few changes to ``MyAdmin`` to add tag field support (detailed
below), and then register it with the default admin site using the standard
``site.register()`` call.
As with the normal registration call, the admin class is optional::
tagulous.admin.register(myModel)
You can also pass a custom admin site into the `register()` function::
# These two lines are equivalent:
tagulous.admin.register(myModel, MyAdmin)
tagulous.admin.register(myModel, MyAdmin, site=admin.site)
The changes Tagulous's ``register()`` function makes to the ``ModelAdmin`` are:
* Changes your ``ModelAdmin`` to subclass ``TaggedAdmin``
* Checks ``list_display`` for any tag fields, and adds functions to the
``ModelAdmin`` to display the tag string (unless an attribute with that name
already exists)
* Switches an inline class to a ``TaggedInlineFormSet`` when necessary
Note:
* You can only provide the Tagulous ``register()`` function with one model.
* The admin class will be modified; bear that in mind if registering it with
multiple admin sites. In that case, you may want to enhance the class
manually, as described below.
Manually enhancing your ModelAdmin
==================================
The ``tagulous.admin.register`` function is the short way to enhance your admin
classes. If for some reason you can't use it (eg another library which has its
own ``register`` function, or you're registering it with more than one admin
site), you can do what it does manually:
1. Change your admin class to subclass ``tagulous.admin.TaggedModelAdmin``.
This disables Django's green button to add a related field, which is
incompatible with Tagulous.
2. Call ``tagulous.admin.enhance(model_class, admin_class)``.
This finds the tag fields on the model class, and adds support for them to
``list_display``.
3. Register the admin class as normal
For example::
import tagulous
class MyAdmin(tagulous.admin.TaggedModelAdmin):
list_display = ['name', 'tags']
tagulous.admin.enhance(MyModel, MyAdmin)
admin.site.register(MyModel, MyAdmin)
Autocomplete settings
=====================
The admin site can use different autocomplete settings to the public site by
changing the settings ``TAGULOUS_ADMIN_AUTOCOMPLETE_JS`` and
``TAGULOUS_ADMIN_AUTOCOMPLETE_CSS``. You may want to do this to avoid jQuery
being loaded more than once, for example - assuming the version in Django's
admin site is compatible with the autocomplete library of your choice.
See :ref:`settings` for more information.
Because the select2 control defaults to use the same width as the form element it
replaces, you may find this a bit too small in some versions of the Django admin. You
could override this with :ref:`option_autocomplete_settings`, but that will change
non-admin controls too, so the best option would be to add a custom stylesheet to
``TAGULOUS_ADMIN_AUTOCOMPLETE_CSS`` with a rule such as::
.select2 {
width: 75% !important;
}
Managing the tag model
======================
Tagulous provides additional tag-related functionality for tag models, such as
the ability to merge tags. You can use Tagulous's ``register`` function to do
this for you - just pass it the tag field::
tagulous.admin.register(MyModel.tags)
You can also specify the tag model directly::
tagulous.admin.register(MyModel.tags.tag_model)
tagulous.admin.register(MyCustomTagModel)
If you have a custom tag model and want to extend the admin class for extra
fields on your custom model, you can subclass the ``TagModelAdmin`` class to
get the extra tag management functionality::
class MyModelTagsAdmin(tagulous.admin.TagModelAdmin):
list_display = ['name', 'count', 'protected', 'my_extra_field']
admin.site.register(MyCustomTagModel, MyModelTagsAdmin)
When overriding options, you should base them on the options in the default
``TagModelAdmin``::
list_display = ['name', 'count', 'protected']
list_filter = ['protected']
exclude = ['count']
actions = ['merge_tags']
The ``TagTreeModelAdmin`` also excludes the ``path`` field.
Remember that the relationship between your entries and tags are standard
``ForeignKey`` or ``ManyToMany`` relationships, so deletion propagation will
work as it would normally.
django-tagulous-1.3.3/docs/changelog.rst 0000664 0000000 0000000 00000025075 14161666113 0020250 0 ustar 00root root 0000000 0000000 =========
Changelog
=========
Tagulous follows semantic versioning in the format ``BREAKING.FEATURE.BUG``:
* ``BREAKING`` will be marked with links to the details and upgrade instructions in
:doc:`upgrading`.
* ``FEATURE`` and ``BUG`` releases will be safe to install without reading the upgrade
notes.
Changes for upcoming releases will be listed without a release date - these
are available by installing the develop branch from github.
1.3.3, 2021-12-25
-----------------
Features:
* Add Django 4.0 support
Bugfix:
* Slug uniqueness now works when there are more than 11 collisions (#152)
1.3.2, 2021-12-23
-----------------
Changes:
* Remove tag lookup from model getstate to improve pickling performance (#143)
* Manager and QuerySet cast classes are now placed in the module of the original class
so they can be imported and found by serializers and picklers
* Cast class names prefixes changed from ``CastTagged`` to ``TagulousCastTagged`` to
further reduce risk of clashes
* Class casting detects and reuses classes which have already been cast
Bugfix:
* QuerySets can be pickled (#142)
1.3.1, 2021-12-21
-----------------
Changes:
* Switch to pytest and enforce linting
Bugfix:
* Fix ``_filter_or_exclude`` exception missed by tests (#144, #149)
Thanks to:
* nschlemm for the ``_filter_or_exclude" fix (#144, #149)
1.3.0, 2021-09-07
-----------------
Features:
* Add ``similarly_tagged`` to tagged model querysets, and ``get_similar_objects`` to
instantiated tag fields (#115)
* New DRF serializer to serialize tags as strings (#111)
* Initial ``TagField`` values passed on ``Form(initial=...)`` can now be a string, list
or tuple of strings or tags, or queryset (#107)
* Add system check for ``settings.SERIALIZATION_MODULES`` (#101)
Bugfix:
* Fix incorrect arguments for the TagField's ``RelatedManager.set``
* Upgrade select2 to fix composed characters (#138)
* Fix select2 input where quotes in quoted tags could be escaped
* The select2 control is applied when the formset:added event adds a tag field (#97)
* Fix edge case circular import (#124)
Thanks to:
* valentijnscholten for the form ``initial=`` solution (#107)
1.2.1, 2021-08-31
-----------------
Bugfix:
* Fix issue with update_or_create (#135)
1.2.0, 2021-08-25
-----------------
Upgrade notes: :ref:`upgrade_1-1-0`
Features:
* Django 3.2 support
* Option ``autocomplete_view_fulltext`` for full text search in autocomplete view (#102)
Changes:
* Slugification now uses standard Django for unicode for consistency
* Add ``autocomplete_view_args`` and ``autocomplete_view_kwargs`` options (#119, #120)
* Documentation updates (#105, #113, #131)
* Fix division by zero issue in ``weight()`` (#102)
Bugfix:
* Fix issue where the Select2 adaptor for SingleTagField didn't provide an empty value,
which meant it would look like it had defaulted to a value which wasn't set. (#116)
* Fix issue where the Select2 adaptor didn't correctly handle the ``required``
attribute, which meant browser field validation would fail silently. (#116)
* Fix dark mode support in Django admin (#125)
* Fix collapsed select2 in Django admin (#123)
* Fix duplicate migration issue (#93)
* Tagged models can now be pickled (#109)
Thanks to:
* BoPeng for the ``autocomplete_view_args`` config options
* valentijnscholten for the select2 doc fix
* Jens Diemer (jedie) for the readme update
* dany-nonstop for ``autocomplete_view_fulltext`` and weight division issue
* poolpoolpoolpool for form.media docs (#131)
1.1.0, 2020-12-06
-----------------
Feature:
* Add Django 3.0 and 3.1 support (#85)
Changes:
* Drops support for Python 2 and 3.5
* Drops support for Django 1.11 and earlier
* Drops support for South migrations
Bugfix:
* Resolves ``ManyToManyRel`` issue sometimes seen in loaddata (#110)
Thanks to:
* Diego Ubirajara (dubirajara) for ``FieldDoesNotExist`` fix for Django 3.1
* Andrew O'Brien (marxide) for ``admin.helpers`` fix for Django 3.1
1.0.0, 2020-10-08
-----------------
Upgrade notes: :ref:`upgrade_0-14-1`
Feature:
* Added adaptor for Select2 v4 and set as default for Django 2.2+ (#11, #12, #90)
* Support full unicode slugs with new ``TAGULOUS_SLUG_ALLOW_UNICODE`` setting (#22)
Changes:
* Drops support for Django 1.8 and earlier
Bugfix:
* Tag fields work with abstract and concrete inheritance (#8)
* Ensure weighted values are integers not floats (#69, #70)
* The admin site in Django 2.2+ now uses the Django vendored versions of jQuery and
select2 (#76)
* Fix support for single character tags in trees (#82)
* Fix documentation for adding registering tagged models in admin (#83)
* Fix division by zero in weight() (#59, #61)
* Fix support for capitalised table name in PostgreSQL (#60, #61)
* Tag fields are stripped before parsing, preventing whitespace tags in SingleTagFields
(#29)
* Fix documentation for quickstart (#41)
* Fix ``prefetch_related()`` on tag fields (#42)
* Correctly raise an ``IntegrityError`` when saving a tree tag without a name (#50)
Internal:
* Signals have been refactored to global handlers (instead of multiple independent
handlers bound to descriptors)
* Code linting improved; project now uses black and isort, and flake8 pases
Thanks to:
* Khoa Pham (phamk) for ``prefetch_related()`` fix (#42, #87)
* Erik Van Kelst (4levels) for division by zero and capitalised table fixes (#60, #61,
#62)
* hagsteel for weighted values fix (#69, #70)
* Michael Röttger (mcrot) for single character tag fix (#81, #82)
* Frank Lanitz (frlan) for admin documentation fix (#83)
0.14.1, 2019-09-04
------------------
Upgrade notes: :ref:`upgrade_0-14-0`
Feature:
* Add Django 2.2 support (closes #71)
* Upgrade example project to Django 2.2 on Python 3.7
Bugfix:
* Correct issue with multiple databases (#72)
Thanks to:
* Dmitry Ivanchenko (ivanchenkodmitry) for multiple database fix (#72)
0.14.0, 2019-02-24
------------------
Feature:
* Add Django 2.0 support (fixes #48, #65)
* Add Django 2.1 support (fixes #56, #58)
Bugfix:
* Fix example project (fixes #64)
Thanks to:
* Diego Ubirajara (dubirajara) for Widget.render() fix (#58)
0.13.2, 2018-05-28
------------------
Feature:
* Tag fields now support the argument :ref:`argument_to_base`
0.13.1, 2018-05-19
------------------
Upgrade notes: :ref:`upgrade_0-13-0`
Bugfix:
* ``TagField(null=...)`` now raises a warning about the ``TagField``, rather than the
parent ``ManyToManyField``.
Changes:
* Reduce support for Python 3.3
0.13.0, 2018-04-30
------------------
Upgrade notes: :ref:`upgrade_0-12-0`
Feature:
* Add Django 1.11 support (fixes #28)
Changes:
* Reduce support for Django 1.4 and Python 3.2
* Remove deprecated ``TagField`` manager's ``__len__`` (#10, fixes #9)
Bugfix:
* Fix failed search in select2 v3 widget when pasting multiple tags (fixes #26)
* Fix potential race condition when creating new tags (#31)
* Temporarily disabled some migration tests which only failed under Python 2.7 with
Django 1.9+ due to logic issues in the tests.
* Fix deserialization exception for model with ``ManyToOneRel`` (fixes #14)
Thanks to:
* Martín R. Guerrero (slackmart) for removing ``__len__`` method (#9, #10)
* Mark London for select2 v3 widget fix when pasting tags (#26)
* Peter Baumgartner (ipmb) for fixing race condition (#31)
* Raniere Silva (rgaics) for fixing deserialization exeption (#14, #45)
0.12.0, 2017-02-26
------------------
Upgrade notes: :ref:`upgrade_0-11-1`
Feature:
* Add Django 1.10 support (fixes #18, #20)
Bugfix:
* Remove ``unique=True`` from tag tree models' ``path`` field (fixes #1)
* Implement slug field truncation (fixes #3)
* Correct MySQL slug clash detection in tag model save
* Correct ``.weight(..)`` to always return floored integers instead of decimals
* Correct max length calculation when adding and removing a value through assignment
* `TagDescriptor` now has a `through` attribute to match `ManyToManyDescriptor`
Deprecates:
* `TagField` manager's `__len__` method is now deprecated and will be removed in 0.13
Thanks to:
* Pamela McA'Nulty (PamelaM) for MySQL fixes (#1)
* Mary (minidietcoke) for max count fix (#16)
* James Pic (jpic) for documentation corrections (#13)
* Robert Erb (rerb) at AASHE (http://www.aashe.org/) for Django 1.10 support (#18, #20)
* Gaël Utard (gutard) for tag descriptor `through` fix (#19)
0.11.1, 2015-10-05
------------------
Internal:
* Fix package configuration in setup.py
0.11.0, 2015-10-04
------------------
Feature:
* Add support for Python 3.2 to 3.5
Internal:
* Change ``tagulous.models.initial.field_initialise_tags`` and ``model_initialise_tags``
to take a file handle as ``report``.
0.10.0, 2015-09-28
------------------
Upgrade notes: :ref:`upgrade_0-9-0`
Feature:
* Add fields ``level`` and ``label`` to :ref:`tagtreemodel` (were properties)
* Add ``TagTreeModel.get_siblings()``
* Add :ref:`tagtreemodel_queryset` methods ``with_ancestors()``,
``with_descendants()`` and ``with_siblings()``
* Add :ref:`option_space_delimiter` tag option to disable space as a delimiter
* Tagulous available from pypi as ``django-tagulous``
* :ref:`TagModel.merge_tags ` can now accept a tag string
* :ref:`TagTreeModel.merge_tags ` can now merge
recursively with new argument ``children=True``
* Support for recursively merging tree tags in admin site
Internal:
* Add support for Django 1.9a1
* ``TagTreeModel.tag_options.tree`` will now always be ``True``
* JavaScript ``parseTags`` arguments have changed
* Added example project to github repository
Bugfix:
* ``TagRelatedManager`` instances can be compared to each other
* Admin inlines now correctly suppress popup buttons
* Select2 adaptor correctly parses ajax response
* :ref:`tagmeta` raises an exception if :ref:`option_tree` is set
* Default help text no longer changes for :ref:`model_singletagfield`
0.9.0, 2015-09-14
-----------------
Upgrade notes: :ref:`upgrade_0-8-0`
Internal:
* Add support for Django 1.7 and 1.8
Removed:
* ``tagulous.admin.tag_model`` has been removed
Bugfix:
* Using a tag field with a non-tag model raises exception
0.8.0, 2015-08-22
-----------------
Upgrade notes: :ref:`upgrade_0-7-0`
Feature:
* Tag cloud support
* Improved admin.register
* Added tag-aware serializers
Deprecated:
* ``tagulous.admin.tag_model`` will be removed in the next version
Bugfix:
* Setting tag options twice raises exception
* Tagged inline formsets work correctly
Internal:
* South migration support improved
* Tests moved to top level, tox support added
* Many small code improvements and bug fixes
0.7.0, 2015-07-01
-----------------
Feature:
* Added tree support
0.6.0, 2015-05-11
-----------------
Feature:
* Initial public preview
django-tagulous-1.3.3/docs/conf.py 0000664 0000000 0000000 00000022224 14161666113 0017057 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#
# django-tagulous documentation build configuration file, created by
# sphinx-quickstart on Tue Sep 15 15:19:30 2015.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
# sys.path.insert(0, os.path.abspath('.'))
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
"sphinx.ext.autodoc",
"sphinx.ext.extlinks",
]
# Add any paths that contain templates here, relative to this directory.
templates_path = ["_templates"]
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
# source_suffix = ['.rst', '.md']
source_suffix = ".rst"
# The encoding of source files.
# source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = "index"
# General information about the project.
project = u"django-tagulous"
copyright = u"2021, Richard Terry"
author = u"Richard Terry"
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
# The full version, including alpha/beta/rc tags.
release = "1.3.3"
version = release.rsplit(".", 1)[0]
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
# today = ''
# Else, today_fmt is used as the format for a strftime call.
# today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ["_build"]
# The reST default role (used for this markup: `text`) to use for all
# documents.
# default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
# add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
# add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
# show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = "sphinx"
# A list of ignored prefixes for module index sorting.
# modindex_common_prefix = []
# If true, keep warnings as "system message" paragraphs in the built documents.
# keep_warnings = False
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = False
extlinks = {
"source": (
"https://github.com/radiac/django-tagulous/blob/master/%s",
"",
),
"issue": ("https://github.com/radiac/django-tagulous/issues/%s", "issue "),
}
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = "alabaster"
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
# html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
# html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# " v documentation".
# html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
# html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
# html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
# html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ["_static"]
# Add any extra paths that contain custom files (such as robots.txt or
# .htaccess) here, relative to this directory. These files are copied
# directly to the root of the documentation.
# html_extra_path = []
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
# html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
# html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
# html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
# html_additional_pages = {}
# If false, no module index is generated.
# html_domain_indices = True
# If false, no index is generated.
# html_use_index = True
# If true, the index is split into individual pages for each letter.
# html_split_index = False
# If true, links to the reST sources are added to the pages.
# html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
# html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
# html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
# html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
# html_file_suffix = None
# Language to be used for generating the HTML full-text search index.
# Sphinx supports the following languages:
# 'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
# 'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr'
# html_search_language = 'en'
# A dictionary with options for the search language support, empty by default.
# Now only 'ja' uses this config value
# html_search_options = {'type': 'default'}
# The name of a javascript file (relative to the configuration directory) that
# implements a search results scorer. If empty, the default will be used.
# html_search_scorer = 'scorer.js'
# Output file base name for HTML help builder.
htmlhelp_basename = "django-tagulousdoc"
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(
master_doc,
"django-tagulous.tex",
u"django-tagulous Documentation",
u"Richard Terry",
"manual",
),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
# latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
# latex_use_parts = False
# If true, show page references after internal links.
# latex_show_pagerefs = False
# If true, show URL addresses after external links.
# latex_show_urls = False
# Documents to append as an appendix to all manuals.
# latex_appendices = []
# If false, no module index is generated.
# latex_domain_indices = True
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
(master_doc, "django-tagulous", u"django-tagulous Documentation", [author], 1)
]
# If true, show URL addresses after external links.
# man_show_urls = False
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(
master_doc,
"django-tagulous",
u"django-tagulous Documentation",
author,
"django-tagulous",
"One line description of project.",
"Miscellaneous",
),
]
# Documents to append as an appendix to all manuals.
# texinfo_appendices = []
# If false, no module index is generated.
# texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
# texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the "Top" node's menu.
# texinfo_no_detailmenu = False
django-tagulous-1.3.3/docs/contributing.rst 0000664 0000000 0000000 00000007777 14161666113 0021041 0 ustar 00root root 0000000 0000000 ============
Contributing
============
Contributions are welcome, preferably via pull request. Check the github issues to see
what needs work. Tagulous aims to be a comprehensive tagging solution, but try to keep
new features from having a significant impact on people who won't use them (eg tree
support is optional).
When submitting UI changes, please aim to support the latest versions of
Chrome, Firefox and Internet Explorer through progressive enhancement - users
of old browsers must still be able to tag things, even if they don't get all
the bells and whistles.
Installing
==========
The easiest way to work on Tagulous is to fork the project on github, then
install it to a virtualenv::
virtualenv django-tagulous
cd django-tagulous
source bin/activate
pip install -e git+git@github.com:USERNAME/django-tagulous.git#egg=django-tagulous
pip install -r src/django-tagulous/requirements.test.txt
(replacing ``USERNAME`` with your username).
This will install the development dependencies too, and you'll find the
tagulous source ready for you to work on in the ``src`` folder of your
virtualenv.
Testing
=======
It is greatly appreciated when contributions come with unit tests.
Pytest is the test runner of choice::
pytest
pytest tests/test_file.py
pytest tests/test_file::TestClass::test_method
Use ``tox`` to run them on one or more supported versions::
tox [-e py39-django3.2]
To use a different database (mysql, postgres etc) use the environment variables
``DATABASE_ENGINE``, ``DATABASE_NAME``, ``DATABASE_USER``,
``DATABASE_PASSWORD``, ``DATABASE_HOST`` and ``DATABASE_PORT``, eg::
DATABASE_ENGINE=pgsql DATABASE_NAME=tagulous_test [...] tox
Most Tagulous python modules have corresponding test modules, with test classes
which subclass ``tests.lib.TagTestManager``. They use test apps defined under
the ``tests`` dir where required.
Run the javascript tests using Jasmine::
pip install jasmine
cd tests
jasmine
# open http://127.0.0.1:8888/ in your browser
Javascript tests are defined in ``tests/spec/javascripts/*.spec.js``.
Code overview
=============
Tag model fields start in :source:`tagulous/models/fields.py`; when they are
added to models, the models call the field's ``contribute_to_class`` method,
which adds the descriptors in :source:`tagulous/models/descriptors.py` onto
the model in their place. These descriptors act as getters and setters,
channeling data to and from the managers in
:source:`tagulous/models/managers.py`.
Models which have tag fields are called tagged models. For tags to be fully
supported in constructors, managers and querysets, those classes need to use
the classes defined in :source:`tagulous/models/tagged.py` as base classes.
That file contains a ``class_prepared`` signal listener which tries to
dynamically change the base classes of any models which contain tag fields.
Model fields take their arguments and store them in a ``TagOptions`` instance,
defined in :source:`tagulous/models/options.py`. Any ``initial`` tags in the
options can be loaded into the database using the functions in
:source:`tagulous/models/initial.py`, which is the same code the
``initial_tags`` management command uses.
When a ``ModelForm`` is created for a model with a tag field, the model field's
``formfield`` method is called. This creates a tag form field, defined in
:source:`tagulous/forms.py`, which is passed the ``TagOptions`` from the model.
A tag form field can also be created directly on a plain form. Tag form fields
in turn uses tag widgets (also in :source:`tagulous/forms.py`) to render the
field to HTML with the data from ``TagOptions``.
Tag strings are parsed and rendered (tags joined back to a tag string) by the
functions in :source:`tagulous/utils.py`.
Everything for enhancing the admin site with support for tag fields is in
:source:`tagulous/admin.py`. It is in two sections; registration (which adds
tag field functionality to a normal ``ModelAdmin``, and replaces the widgets
with tag widgets) and tag model admin (for managing tag models).
django-tagulous-1.3.3/docs/forms.rst 0000664 0000000 0000000 00000016574 14161666113 0017453 0 ustar 00root root 0000000 0000000 =====
Forms
=====
Normally tag fields will be used in a ``ModelForm``; they will automatically
use the correct form field and widget to render tag fields with your
selected :ref:`autocomplete adaptor `.
To save tag fields, just call the ``form.save()`` method as you would normally.
However, because :ref:`model_tagfield` is based on a ``ManyToManyField``, if
you call ``form.save(commit=False)`` you will need to call ``form.m2m_save()``
after to save the tags.
See the :ref:`example_modelform` example for how this works in practice.
Form field classes
==================
You can also use Tagulous form fields outside model forms by using the
:ref:`form_singletagfield` and :ref:`form_tagfield` form fields - see the
:ref:`example_form` example for how this works in practice.
Tag forms fields take standard `Django core field arguments `_
such as ``label`` and ``required``.
.. _form_singletagfield:
``tagulous.forms.SingleTagField``
---------------------------------
This field accepts two new arguments:
``tag_options``
A :ref:`TagOptions ` instance, containing
:ref:`form options ` (model options will be ignored).
``autocomplete_tags``
An iterable of tags to be embedded for autocomplete. This can either be
a queryset of tag objects, or a list of tag objects or strings.
The ``clean`` method returns a single tag name string, or ``None`` if the
value is empty.
.. _form_tagfield:
``tagulous.forms.TagField``
---------------------------
This field accepts the same two new arguments as a ``SingleTagField``:
``tag_options``
A :ref:`TagOptions ` instance, containing
:ref:`form options ` (model options will be ignored).
``autocomplete_tags``
An iterable of tags to be embedded for autocomplete. This can either be
a queryset of tag objects, or a list of tag objects or strings.
The ``clean`` method returns a sorted list of unique tag names (a list of
strings) - or an empty list if there are no tags.
``tagulous.forms.TaggedInlineFormSet``
--------------------------------------
In most cases Tagulous works with Django's default inline model formsets, and
you don't need to do anything special.
However, there is a specific case where it doesn't: when you create an inline
formset for tagged models, with a tag as their parent model - eg when you edit
a tag and its corresponding instances of the tagged model. That is when you
must use the ``TaggedInlineFormSet`` class. For example::
class Person(models.Model):
name = models.CharField(max_length=255)
title = tagulous.models.SingleTagField(initial='Mr, Mrs')
PersonInline = forms.models.inlineformset_factory(
Person.title.tag_model,
Person,
formset=tagulous.forms.TaggedInlineFormSet,
)
This would allow you to generate a formset for all ``Person`` objects which
use a specific ``title`` tag.
Tagulous will automatically apply this fix in the admin site, as long as the
tag admin class is registered using ``tagulous.admin.register``.
Without the ``TaggedInlineFormSet`` class in this situation, the tag count will
be incorrect when adding tagged model instances, and editing will fail because
the default formset will try to use the tag name as a primary key.
The ``TaggedInlineFormSet`` class will only perform actions under this specific
relationship, so is safe to use in other situations.
.. _filter_autocomplete:
Filtering autocomplete tags
===========================
By default the tag field widget will autocomplete using all tags on the tag
model. However, you will often only want to use a subset of your tags - for
example, just the initial tags, or tags which the current user has used, or
tags which have been used in conjunction with another field on your model.
Because model tag fields are normal Django relationships, you can filter
embedded autocomplete tags by overriding the form's ``__init__`` method. To
filter an ajax autocomplete view, wrap ``tagulous.views.autocomplete`` in your
own view function which filters for you.
For examples of these approaches, see :ref:`example_filter_embedded` and
:ref:`example_filter_autocomplete_view`.
.. _autocomplete_adaptors:
Autocomplete Adaptors
=====================
Tagulous uses a javascript file it calls an ``adaptor`` to apply your chosen
autocomplete library to the Tagulous form field.
Only Select2 is included with Tagulous; if you want to use a different library,
you will need to add it to your project's static files, and add the relative
path under ``STATIC_URL`` to the appropriate ``TAGULOUS_`` settings.
Tagulous includes the following adaptors:
Select2 (version 4)
-------------------
The default adaptor, for `Select2 `_.
Path:
``tagulous/adaptor/select2-4.js``
Autocomplete settings should be a dict:
``defer``
If ``True``, the tag field will not be initialised automatically; you
will need to call ``Tagulous.select2(el)`` on it from your own
javascript. This is useful for fields which are used as templates to
dynamically generate more.
For example, to use this adaptor with a
`django-dynamic-formset `_
which uses a ``formTemplate``, set ``{'defer': True}``, then configure
the formset with::
added: function ($row) {
Tagulous.select2($row.find('input[data-tagulous]'));
}
Note that when used with inline formsets which raise the ``formset:added`` event
(like in the Django admin site), Tagulous will automatically try to register tag
fields in new formsets if ``defer=False``.
``width``
This is the same as in Select2's documentation, but the Tagulous
default is ``resolve`` instead of ``off``, for the best chance of
working without complication.
All other settings will be passed to the Select2 constructor.
.. _custom_autocomplete_adaptor:
Writing a custom autocomplete adaptor
=====================================
Writing a custom adaptor should be fairly self-explanatory - take a look at the
included adaptors to see how they work. It's mostly just a case of pulling data
out of the HTML field, and fiddling with it a bit to pass it into the library's
constructor.
Tagulous puts certain settings on the HTML field's ``data-`` attribute:
``data-tagulous``
Always ``true`` - used to identify a tagulous class to JavaScript
``data-tag-type``
Set to ``single`` when a ``SingleTagField``, otherwise not present.
``data-tag-list``
JSON-encoded list of tags.
``data-tag-url``
URL to request tags
``data-tag-options``
JSON-encoded dict of tag options
In addition to the dict from ``TagOptions`` containing the field's
:ref:`form_options`, there will also be:
``required``
A boolean indicating whether the form field is required or not
These settings can be used to initialise your autocomplete library of choice.
You should initialise it using ``data-tag-options``'s ``autocomplete_settings``
for default values.
For consistency with Tagulous's :ref:`python parser `, try to
replace your autocomplete library's parser with Tagulous's
:ref:`javascript parser `.
If you write an adaptor which you think would make a good addition to this
project, please do send it in or make a pull request on github - see
:doc:`contributing` for more information.
django-tagulous-1.3.3/docs/index.rst 0000664 0000000 0000000 00000001175 14161666113 0017423 0 ustar 00root root 0000000 0000000 ===============================
Django Tagulous - Fabulous Tags
===============================
Tagulous is a fully-featured tagging library for Django built on ``ForeignKey``
and ``ManyToManyField``, giving you all their normal power with a sprinkling of
tagging syntactic sugar, and a full set of extra
:doc:`features `.
.. seealso::
Read this online at http://radiac.net/projects/django-tagulous/
Contents
========
.. toctree::
:maxdepth: 2
introduction
installation
usage
parser
models/index
forms
tag_options
views
admin
changelog
upgrading
contributing
django-tagulous-1.3.3/docs/installation.rst 0000664 0000000 0000000 00000020020 14161666113 0021003 0 ustar 00root root 0000000 0000000 ============
Installation
============
.. _installation_instructions:
Instructions
============
1. Install ``django-tagulous``::
pip install django-tagulous
2. In your site settings, add Tagulous to ``INSTALLED_APPS`` and tell Django to use the
Tagulous serialization modules::
INSTALLED_APPS = (
...
'tagulous',
)
SERIALIZATION_MODULES = {
'xml': 'tagulous.serializers.xml_serializer',
'json': 'tagulous.serializers.json',
'python': 'tagulous.serializers.python',
'yaml': 'tagulous.serializers.pyyaml',
}
There are other global :ref:`settings` you can add here.
3. Add Tagulous fields to your project - see :doc:`models/index`, :doc:`forms` and
:doc:`usage`.
Remember to run ``manage.py collectstatic`` to collect the JavaScript and CSS resources.
When you want to upgrade your Tagulous installation in the future, check
:doc:`upgrading` to see if there are any special actions that you need to take.
.. note::
If you use MySQL there are some limitations you should be aware of - see:
* the :ref:`setting ` for max length for limitations of maximum
tag lengths
* the tag option :ref:`option_case_sensitive` for limitations of case
sensitivity.
.. _settings:
Settings
========
.. note::
Model and form field options are managed separately by :doc:`tag_options`.
``TAGULOUS_NAME_MAX_LENGTH``
``TAGULOUS_SLUG_MAX_LENGTH``
``TAGULOUS_LABEL_MAX_LENGTH``
Default max lengths for tag models.
.. note::
When MySQL is using utf8mb4 charset, all unique fields have a
max-length of 191 characters, because MySQL max key length in 767
bytes and utf8mb4 reserves 4 bytes per character, thus 767/4 = 191.
If you use MySQL, we therefore recommend the following settings:
TAGULOUS_NAME_MAX_LENGTH=191
Default::
TAGULOUS_NAME_MAX_LENGTH = 255
TAGULOUS_SLUG_MAX_LENGTH = 50
TAGULOUS_LABEL_MAX_LENGTH = TAGULOUS_NAME_MAX_LENGTH
``TAGULOUS_SLUG_TRUNCATE_UNIQUE``
Number of characters to allow for the numerical suffix when finding a
unique slug, ie if set to 5, the slug will be truncated by up to 5
characters to allow for a suffix of up to `_9999`.
Default: ``5``
``TAGULOUS_SLUG_ALLOW_UNICODE``
If ``True`` unicode will be allowed in slugs. If ``False`` tag slugs will be forced
to ASCII.
As with Django's ``slugify``, this is off by default.
Default: ``False``
``TAGULOUS_AUTOCOMPLETE_JS``
``TAGULOUS_ADMIN_AUTOCOMPLETE_JS``
List of static JavaScript files required for Tagulous autocomplete. These will be
added to the form media when a Tagulous form field is used.
The order is important: the adaptor must appear last in the list, so that
it is loaded after its dependencies.
If you use jQuery elsewhere on your site, you may need to remove `jquery.js` to
avoid conflicts.
Default::
TAGULOUS_AUTOCOMPLETE_JS = (
"tagulous/lib/jquery.js",
"tagulous/lib/select2-4/js/select2.full.min.js",
"tagulous/tagulous.js",
"tagulous/adaptor/select2-4.js",
)
``TAGULOUS_AUTOCOMPLETE_CSS``
``TAGULOUS_ADMIN_AUTOCOMPLETE_CSS``
List of static CSS files required for Tagulous autocomplete. These will be added to
the form media when a Tagulous form field is used.
The default list will use the included version of Select2.
Default::
TAGULOUS_AUTOCOMPLETE_CSS = {
'all': ['tagulous/lib/select2-4/css/select2.min.css']
}
``TAGULOUS_AUTOCOMPLETE_SETTINGS``
Any settings to pass to the JavaScript via the adaptor. They can be overridden by a
field's :ref:`autocomplete_settings ` option.
For example, the select2 control defaults to use the same width as the form element
it replaces; you can override this by passing their ``width`` option (see their docs
on `appearance `_) as an autocomplete setting::
TAGULOUS_AUTOCOMPLETE_SETTINGS = {"width": "75%"}
If set to ``None``, no settings will be passed.
Default: ``None``
``TAGULOUS_WEIGHT_MIN``
The default minimum value for the :ref:`weight ` queryset method.
Default: ``1``
``TAGULOUS_WEIGHT_MAX``
The default maximum value for the :ref:`weight ` queryset method.
Default: ``6``
``TAGULOUS_ENHANCE_MODELS``
**Advanced usage** - only use this setting if you know what you're doing.
Tagulous automatically enhances models, managers and querysets to fully support tag
fields. This has the theoretical potential for unexpected results, so this setting
lets the cautious disable this enhancement.
If you set this to False you will need to manually add Tagulous mixins to your
models, managers and querysets.
See :doc:`models/tagged_models` for more information.
Default: ``True``
System checks
=============
Tagulous adds to the Django system check framework with the following:
``tagulous.W001``
``settings.SERIALIZATION_MODULES`` has not been configured as expected
A common installation error is to forget to set ``SERIALIZATION_MODULES`` as
described in the :ref:`installation instructions `.
This is a straight string comparison. If your serialisation modules don't match what
Tagulous is expecting (you're subclassing the Tagulous modules, for example), you
can disable this warning with the setting::
SILENCED_SYSTEM_CHECKS = ["tagulous.W001"]
.. _converting_to_tagulous:
Converting to Tagulous
======================
If you're already using a tagging library which you'd like to replace with
Tagulous, freeze the tags into a temporary column, remove the old tagging code,
add a new tagulous TagField, then copy the tags back across.
.. warning::
This hasn't been tested with your data, so back up your database first,
just in case.
1. Create a schema migration to add a ``TextField`` to your tagged
model, where we'll temporarily store the tags for that instance.
``django-taggit`` example::
class MyModel(models.Model):
...
tags = TaggableManager()
tags_store = models.TextField(blank=True)
``django-tagging`` example::
class MyModel(models.Model):
...
tags_store = models.TextField(blank=True)
tagging.register(MyModel)
2. Create a data migration to copy the tags into the new field as a
string.
``django-taggit`` example::
def store_tags(apps, schema_editor):
import tagulous
model = apps.get_model('myapp', 'MyModel')
for obj in model.objects.all():
obj.tags_store = tagulous.utils.render_tags(obj.tags.all())
class Migration(migrations.Migration):
operations = [
migrations.RunPython(store_tags)
]
The example for ``django-tagging`` would be the same, only replace
``obj.tags.all()`` with ``obj.tags``.
3. Remove the old tagging code from your model, and create a schema migration
to clean up any unused fields or models.
4. Add a ``TagField`` to your tagged model and create a schema migration::
import tagulous
class MyModel(models.Model):
tags = tagulous.models.TagField()
tags_store = models.TextField(blank=True)
Be careful to set appropriate arguments, ie ``blank=True`` if some of your
``tags_store`` fields may be empty.
5. Create a data migration to copy the tags into the new field.
Example::
def load_tags(apps, schema_editor):
model = apps.get_model('myapp', 'MyModel')
for obj in model.objects.all():
obj.tags = obj.tags_store
obj.tags.save()
class Migration(migrations.Migration):
operations = [
migrations.RunPython(load_tags)
]
6. Create a schema migration to remove the temporary tag storage field
(``tag_store`` in these examples)
7. Apply the migrations and start using tagulous
django-tagulous-1.3.3/docs/introduction.rst 0000664 0000000 0000000 00000016515 14161666113 0021041 0 ustar 00root root 0000000 0000000 ============
Introduction
============
Features
========
* Easy to install - simple requirements, simple syntax, lots of options
* Based on ForeignKey and ManyToManyField, so it's easy to query
* Autocomplete support built in, if you want it
* Supports multiple independent tag fields on a single model
* Can be used as a CharField with dynamic choices
* Supports trees of nested tags, for detailed categorisation
* Admin support for managing tags and tagged models
.. _quickstart:
Quickstart
==========
Install with ``pip install django-tagulous``, add ``tagulous`` to Django's
``INSTALLED_APPS`` and :doc:`define the serializers `, then start adding
tag fields to your model::
from django.db import models
from tagulous.models import SingleTagField, TagField
class Person(models.Model):
name = models.CharField(max_length=255)
title = SingleTagField(initial="Mr, Mrs, Miss, Ms")
skills = TagField()
A ``SingleTagField`` is based on a ``ForeignKey``, and a ``TagField`` is based
on a ``ManyToManyField``.
They have relationships to a ``TagModel``, which is automatically created for you if you
don't specify one.
Assign strings to the fields to create new tags::
myperson = Person.objects.create(name='Bob', title='Mr', skills='run, hop')
# myperson.skills == 'run, hop'
myperson.skills = ['jump', 'kung fu']
myperson.save()
# myperson.skills == 'jump, "kung fu"'
runners = Person.objects.filter(skills='run')
Use them like a normal Django relationship in your queries::
qs = MyRelatedModel.objects.filter(
person__skills__name__in=['run', 'jump'],
)
As well as this you also get:
* tag field support in public :doc:`forms ` and the :doc:`admin `
site, including autocompletion
* easy to build :ref:`tag clouds `
* ability to nest tags in :doc:`trees ` for more complex
categorisation
Take a look at the :doc:`usage` to see what else you can do, or read on through
the :doc:`documentation ` to see exactly how everything works.
Glossary
========
This documentation uses a few terms to explain the ways tags are stored and
set:
Tagged model
A model which has been tagged using :doc:`models/fields`.
Tag model
A model where the tag definition is stored. It must be a subclass of
:ref:`tagmodel`, but will be auto-generated by a tag field if it is not
explicitly set.
Tag
An instance of a tag model
Tag name
The unique name of a tag, eg ``"run"``. This is the value stored on the
``name`` attribute of a tag model.
Tag string
A tag string is a list of tag names stored in a single string, in tag
format, eg ``"run, jump, hop"``. The format of this string is defined
by the :doc:`parser`.
Comparison with other tagging libraries
=======================================
Popular tagging libraries for Django include:
* `django-taggit `_
* `django-tagging `_
* `django-tagging-ng `_
If you are already using one of these, read
:ref:`converting_to_tagulous` to see what is involved in switching to Tagulous.
Tagulous is easier to use and has more features, and is a proven library which has been
in use since Django 1.4.
Real relations
--------------
The Tagulous ``TagField`` is based on ``ManyToManyField``, so you can set and query tag
objects like a normal M2M field, but also use tag strings and lists of tag names.
django-tagging and django-taggit both use generic relations, which tend to be
second-class citizens in Django - they are often slower and lack functionality compared
to native FK and M2M fields. This means they have a more convoluted syntax and queries
are more complex and limited.
Separate tag models
-------------------
In Tagulous, tag models can be independent or shared - this allows you to have multiple
tag fields on one model which each have their own sets of tags, or share sets of tags
between fields and models as you wish - see the :doc:`models/tag_models` documentation
for more details.
You can also easily define custom tag models in Tagulous, to store additional data on
with tags - see the :ref:`custom_tag_models` documentation and
:ref:`this example ` for more details.
django-taggit can be configured to use custom models so it can have separate sets of
tags, but requires a bit more work. django-tagging does not support separate sets of
tags or custom models.
More customisable
-----------------
Tagulous is designed to be configurable. For example, it lets you protect tags from
being removed when they're no longer in use, they can be case sensitive, forced to
lowercase, you can specify a maximum number of tags for a field, and whether or not
space should be used as a delimiter. See the :doc:`tag_options` documentation for more
details.
django-tagging only lets you force tags to lowercase, and django-taggit
only lets you toggle case sensitivity.
Built-in autocomplete
---------------------
Tagulous has built-in support for autocomplete; tags can either be embedded into the
page, or queried using the ajax views provided. It uses Select2, but it has been
designed to be easy to switch that out for something else using
:ref:`autocomplete adaptors `.
The JavaScript and Python code is closely integrated - the same tag parser has been
implemented in both to ensure tag strings are treated consistently.
Neither django-tagging and django-taggit support autocomplete out of the box; you need
to add another library to do that.
Better admin support
--------------------
Tagulous tag fields are first-class citizens in Django's admin site. You can show them
in ``list_display``, use them to filter your model, and can register tag models to
rename and merge tags. Tag fields and autocomplete work throughout admin forms and
inlines. See the :doc:`admin` documentation for more details.
django-tagging and django-taggit tags cannot be shown in ``list_display``,
and there are no special admin tools.
Single tag mode
---------------
The standard ``TagField`` is based on a ``ManyToManyField`` for conventional tagging,
but Tagulous also provides a ``SingleTagField``, which is based on ``ForeignKey``. This
acts more like a ``CharField`` with dynamic ``choices`` that users can add to at
runtime. See the :doc:`models/fields` documentation for more details.
django-tagging and django-taggit don't have an equivalent feature.
Hierarchical tag trees
----------------------
Tagulous has a tree mode, which lets you create sub-tags using the ``/`` character in a
tag name. You can query and navigate a tag tree as you would expect (querying for
parents, siblings, children, descendants etc), as well as rename and merge subtrees from
your code or the Django admin. See the :doc:`models/tag_trees` documentation for more
details.
django-tagging and django-taggit don't have an equivalent feature.
And there's more
----------------
Tagulous is packed with small features which make it easy to work with,
such as:
* a more robust :doc:`tag string parser ` with better support for quoted tags.
* automatic :ref:`slug ` generation, and :ref:`path ` generation
for tree tags.
* tag model managers and querysets have a :ref:`weight `
method to make it easy to build custom tag clouds.
django-tagulous-1.3.3/docs/models/ 0000775 0000000 0000000 00000000000 14161666113 0017041 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/docs/models/fields.rst 0000664 0000000 0000000 00000030676 14161666113 0021055 0 ustar 00root root 0000000 0000000 ============
Model Fields
============
Tagulous offers two new model field types:
* :ref:`model_tagfield` - conventional tags using a ``ManyToManyField``
relationship.
* :ref:`model_singletagfield` - the same UI and functionality as a ``TagField``
but for a single tag, using a ``ForeignKey`` relationship.
These will automatically create the models for the tags themselves, or you can
provide a custom model to use instead with ``to`` - see
:ref:`custom_tag_models` for more details.
Tagulous lets you get and set string values using these fields, while still
leaving the underlying relationships available. For example, not only can
you assign a queryset or list of tag primary keys to a ``TagField``, but you
can also assign a list of tag names, or a tag string to parse.
Like a ``CharField``, changes made by assigning a value will not be committed
until the model is saved, although you can still make immediate changes by
calling the standard m2m methods ``add``, ``remove`` and ``clear``.
If ``TAGULOUS_ENHANCE_MODELS`` is ``True`` (which it is by default -
see :ref:`settings`), you can also use tag strings and lists of tag names in
``get`` and ``filter``, and model constructors and ``object.create()`` - see
:doc:`tagged_models` for more details.
.. _model_field_arguments:
Model Field Arguments
=====================
The ``SingleTagField`` supports most standard ``ForeignKey`` arguments, except
for ``to_field`` and ``rel_class``.
The ``TagField`` supports most normal ``ManyToManyField`` arguments, except
for ``db_table``, ``through`` and ``symmetrical``. Also note that ``blank`` has
no effect at the database level, it is just used for form validation - as is
the case with a normal ``ManyToManyField``.
The ``related_name`` will default to ``_set``, as is normal for a
``ForeignKey`` or ``ManyToManyField``. If using the same tag table on multiple
fields, you will need to set this to something else to avoid clashes.
.. _field_auto_model:
Auto-generating a tag model
---------------------------
If the :ref:`to argument ` is not set, a tag model will be
auto-generated for you. It will be given a class name based on the names of
the tagged model and tag field; for example, the class name of the
auto-generated model for ``MyModel.tags`` would be ``Tagulous_MyModel_tags``.
When auto-generating a model, any :ref:`model option ` can be
passed as a field argument - see the :ref:`example_auto_tagmodel` example.
If you want to override the default base class, for convenience you can specify
a custom base class for the auto tag model - see the :ref:`argument_to_base`
argument for details.
.. _field_explicit_model:
Specifying a tag model
----------------------
You can specify the tag model for the tag field to use with the
:ref:`to argument `. You cannot specify any tag options.
.. _argument_to:
``to=MyTagModel`` (or first unnamed argument)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Manually specify a tag model for this tag field. This can either be a
reference to the tag model class, or string reference to it in the format
``app.model``.
This will normally be a :ref:`custom tag model `, which
must be a subclass of ``tagulous.models.TagModel``.
It can also be a reference to a tag model already auto-generated by another
tag field, eg ``to=MyOtherModel.tags.tag_model``, although you must be
confident that ``MyOtherModel`` will always be defined first.
It can also be a string containing the name of the tag model, eg
``to='MyTagModel'``. However, this is resolved using Django's standard model
name resolution, so you have to reference auto-generated models by their class
name, not via the field - eg ``to='otherapp.Tagulous_MyOtherModel_tags'``.
If the tagged model for this field is also a custom tag model, you can
specify a recursive relationship as normal, using ``'self'``.
If it is a custom tag model, it should have a :ref:`tagmeta` class. Fields
which specify their tag model cannot provide new tag model options; they
will take their options from the model - see :doc:`../tag_options` for more
details.
This argument is optional; if omitted, a tag model will be
:ref:`auto-generated ` for you.
Default: ``Tagulous__`` (auto-generated)
.. _argument_to_base:
``to_base=MyTagModelBase``
~~~~~~~~~~~~~~~~~~~~~~~~~~
You can specify a base class to use for an auto-generated tag model, instead of
using ``TagModel``.
This can be useful on complex sites where multiple auto-generated tag models
need to share common custom functionality - for example, tracking and filtering
by user who creates the tags. This argument will allow you to define one base
class and re-use it across your project with less boilerplate than defining
many empty custom tag models.
Default: ``tagulous.models.TagModel``
.. _model_singletagfield:
``tagulous.models.SingleTagField``
==================================
Unbound field
-------------
An unbound ``SingleTagField`` (called on a model class, eg ``MyModel.tag``)
acts in the same way an unbound ``ForeignKey`` field would, but also has:
``tag_model``
The related tag model
``tag_options``
A :ref:`TagOptions ` class, containing the options from the tag
model's :ref:`tagmeta` or passed as arguments when initialising the field.
Bound to an instance
--------------------
A bound ``SingleTagField`` (called on an instance, eg ``instance.tags``) acts
in a similar way to a bound ``ForeignKey``, but with some differences:
Assignment (setter)
A bound ``SingleTagField`` can be assigned a tag (an instance of the
tag model) or a tag name.
If it is passed ``None``, a current tag will be cleared if it is set.
The instance must be saved afterwards.
Example::
person.title = "Mr"
person.save()
Evaluation (getter)
The value of a bound ``SingleTagField`` will return an instance of the tag
model. The tag may not exist in the database yet (its ``pk`` may be
``None``).
Example::
tag = person.title
report = "Tag %s used %d times " % (tag.name, tag.count)
The ``tag_model`` and ``tag_options`` attributes are not available on a bound
field. If you only have an instance of the tagged model, you can access them by
finding its class, eg ``type(person).title.tag_model``.
.. _model_tagfield:
``tagulous.models.TagField``
============================
Unbound field
-------------
An unbound ``TagField`` (called on a model class, eg ``MyModel.tags``)
acts in the same way an unbound ``ManyToManyField`` would, but also has:
``tag_model``
The related tag model
``tag_options``
A :ref:`TagOptions ` class, containing the options from the tag
model's :ref:`tagmeta` or passed as arguments when initialising the field.
Bound to an instance
--------------------
A bound ``TagField`` (called on an instance, eg ``instance.tags``) acts
in a similar way to a bound ``ManyToManyField``, but with some differences:
Assignment (setter)
A bound ``TagField`` can be assigned a tag string or an iterable of tags or
tag names, eg a list of strings, or a queryset of instances of the tag
model.
If it is passed ``None``, any current tags will be cleared.
The instance must be saved afterwards.
Example::
person.skills = 'Judo, "Kung Fu"'
person.save()
Evaluation (getter)
A bound ``TagField`` will return a :ref:`tagrelatedmanager` object, which
has functions to get and set tag values.
.. _tagrelatedmanager:
``tagulous.models.TagRelatedManager``
-------------------------------------
A ``TagRelatedManager`` is a subclass of Django's standard ``RelatedManager``,
so you can do anything you would normally do with a bound ``ManyToManyField``::
person.skills.get(name='judo')
tags = person.skills.all()
person.skills.add(MyTag)
person.skills.clear()
Because it's a relationship to a :doc:`tag model `, you can also
filter by its fields::
filtered_tags = person.skills.filter(name__startswith='a')
popular_tags = person.skills.filter(count__gte=10)
A ``TagRelatedManager`` also provides access to the field's ``tag_model`` and
``tag_options``::
person.skills.tag_model.objects.all()
is_lowercase = person.skills.tag_options.force_lowercase
It also provides the following additional methods:
``set_tag_string(tag_string)``
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Sets the tags for this instance, given a tag string.
::
person.skills.set_tag_string('Judo, "Kung Fu"')
person.save()
``set_tag_list(tag_list)``
~~~~~~~~~~~~~~~~~~~~~~~~~~
Sets the tags for this instance, given an iterable of tag names or tag
instances.
::
person.skills.set_tag_list(['Judo', kung_fu_tag])
person.save()
``get_tag_string()``
~~~~~~~~~~~~~~~~~~~~
Gets the tags as a tag string.
::
tag_string = person.skills.get_tag_string()
# tag_string == 'Judo, "Kung Fu"'
``get_tag_list()``
~~~~~~~~~~~~~~~~~~
Returns a list of tag names.
::
tag_list = person.skills.get_tag_list()
# tag_list == ['Judo', 'Kung Fu']
``__str__()``, ``__unicode__()``
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Same as ``get_tag_string``
::
report = '%s' % person.skills
``__eq__``, ``__ne__``
~~~~~~~~~~~~~~~~~~~~~~
Compare the tags on this instance to a tag string, or an iterable of tags
or tag names. Order does not matter, and case sensitivity is determined by
the options :ref:`option_case_sensitive` and :ref:`option_force_lowercase`.
::
if (
first.tags == second.tags
or first.tags == ['Judo', kung_fu_tag]
or first.tags != 'foo, bar'
or first.tags != second.tags.filter(name__istartswith='k')
):
...
``__contains__``
~~~~~~~~~~~~~~~~
See if the tag (or string of a tag name) is in the tags. Case sensitivity
is determined by the options :ref:`option_case_sensitive` and
:ref:`option_force_lowercase`.
::
if 'Judo' in person.skills and kung_fu_tag in person.skills:
candidates.append(person)
``reload()``
~~~~~~~~~~~~
Discard any unsaved changes to the tags and load tags from the database
::
person.skills = 'judo'
person.save()
person.skills = 'karate'
person.skills.reload()
# person.skills == 'judo'
``save(force=False)``
~~~~~~~~~~~~~~~~~~~~~
Commit any tag changes to the database.
If you are only changing the tags you can call this directly to reduce
database operations.
.. note::
You do not need to call this if you are saving the instance; the
manager listens to the instance's save signals and saves any changes
to tags as part of that process.
In most circumstances you can ignore the ``force`` flag:
* The manager has a ``.changed`` flag which is set to ``False`` whenever
the internal tag cache is loaded or saved. It is set to ``True`` when the
tags are changed without being saved.
* If ``force=False`` (default), this method will only update the database
if the ``.changed`` flag is ``True`` - in other words, the database will
only be updated if there are changes to the internal cache since last
load or save.
* If ``force=True``, the ``.changed`` flag will be ignored, and the current
tag status will be forced upon the database. This can be useful in the
rare cases where you have multiple references to the same database
object, and want the tags on this instance to override any changes other
instances may have made.
For example::
person = Person.objects.create(name='Adam', skills='judo')
person.name = 'Bob'
person.skills = 'karate'
person.skills.save()
# person.name == 'Adam'
# person.skills == 'judo'
``add(tag, tag, ...)``
~~~~~~~~~~~~~~~~~~~~~~
Based on the normal ``RelatedManager.add`` method, but has support for tag
names.
Adds a list of tags or tag names directly to the instance - there is no
need to save afterwards.
.. note::
This does not parse tag strings - you need to pass separate tags
as either instances of the tag model, or as separate strings.
Will call ``reload()`` first, so any unsaved changes to tags will be lost.
::
person.skills.add('Judo', kung_fu_tag)
``remove(tag, tag, ...)``
~~~~~~~~~~~~~~~~~~~~~~~~~
Based on the normal ``RelatedManager.remove`` method, but has support for
tag names.
Removes a list of tags or tag names directly from the instance - there is
no need to save afterwards.
.. note::
This does not parse tag strings - you need to pass separate tags
as either instances of the tag model, or as separate strings.
Will call ``reload()`` first, so any unsaved changes to tags will be lost.
::
person.skills.remove('Judo', kung_fu_tag)
django-tagulous-1.3.3/docs/models/index.rst 0000664 0000000 0000000 00000001647 14161666113 0020712 0 ustar 00root root 0000000 0000000 ======
Models
======
Tagulous provides two new :doc:`model fields ` - :ref:`model_tagfield`
and :ref:`model_singletagfield`, which you use to add tags to your existing
models to make them :doc:`tagged models `. They provide extra
tag-related functionality.
They can also be queried like a normal Django ``ForeignKey`` or
``ManyToManyField``, but with extra :ref:`query enhancements ` to
make working with tags easier.
Tags are stored in :doc:`tag model ` subclasses, which can either
be unique to each different tag field, or can be shared between them. If you
don't specify a tag model on your field definition, one will be created for you
automatically.
Tags can be nested using :doc:`tag trees `. There is also support
for :doc:`database migrations `.
.. toctree::
:maxdepth: 2
fields
tag_models
tag_trees
tagged_models
migrations
django-tagulous-1.3.3/docs/models/migrations.rst 0000664 0000000 0000000 00000004506 14161666113 0021754 0 ustar 00root root 0000000 0000000 ===================
Database Migrations
===================
Tagulous supports Django migrations.
Both ``SingleTagField`` and ``TagField`` work in schema and data migrations.
Tagged models will be subclasses of ``TaggedModel`` as normal (as long as
``TAGULOUS_ENHANCE_MODELS`` is ``True``), and tag fields will work as normal.
The only difference is that tag models will be instances of ``BaseTagModel``
and ``BaseTagTreeModel`` rather than their normal non-base versions - but this
is just how migrations work, and it will makes no practical difference.
Adding unique columns
=====================
Migrating a model to a ``TagModel`` or ``TagTreeModel`` involves adding unique fields
(``slug`` and ``path`` for example), which normally requires 3 separate migrations. To
simplify this process, Tagulous provides the helper method ``add_unique_field`` to add
them in a single migration - see step 2 in :ref:`converting_tag_trees` for examples of
their use.
However, use these with care - should part of the function fail for some reason
when using a non-transactional database, it won't be able to roll back and may
be left in an unmigrateable state. It is therefore recommended that you either
make a backup of your database before using this function, or that you follow
the steps in the
`official Django documentation `_
to perform the action in 3 separate migrations.
.. _migrations_limitations:
Limitations of Django migrations
================================
Django migrations do not support changing the tag model's base class - for
example, changing a plain model to a ``TagModel``, or a ``TagModel`` to a
``TagTreeModel``). Django migrations have no way to store or apply this change,
so you will need to use the Tagulous helper operation ``ChangeModelBases`` -
see step 3 of :ref:`converting_tag_trees` for more details, or the working
example in
:source:`0003_tree.py `.
Django migrations also cannot serialise lambda expressions, so the
``get_absolute_url`` argument is not available during data migrations, neither
when defined on a tag field, nor when in a tag model. If you need to call this
in a data migration, it is recommended that you embed the logic into your
migration.
django-tagulous-1.3.3/docs/models/tag_models.rst 0000664 0000000 0000000 00000013056 14161666113 0021716 0 ustar 00root root 0000000 0000000 ==========
Tag Models
==========
Tags are stored in tag models which subclass :ref:`tagmodel`, and use a
:ref:`tagmodel_manager`. A tag model can either be generated automatically,
or you can create a :ref:`custom model `.
Tags in tag models can be :ref:`protected ` from automatic
deletion when they are not referred to. :ref:`Initial tags `
must be loaded using the :ref:`initial_tags command `.
Tag model classes
=================
.. _tagmodel:
``tagulous.models.TagModel``
----------------------------
A ``TagModel`` subclass has the following fields and methods:
``name``
~~~~~~~~
A ``CharField`` containing the name (string value) of the tag.
Must be unique.
.. _model_slug:
``slug``
~~~~~~~~
A unique ``SlugField``, generated automatically from the name when first
saved.
Slugs will support unicode if the ``TAGULOUS_SLUG_ALLOW_UNICODE``
:ref:`setting ` is ``True``. Empty slugs are not allowed; they will default to
underscore. Slug clashes are avoided by adding an integer to the end.
``count``
~~~~~~~~~
An ``IntegerField`` holding the number of times this tag is in use.
``protected``
~~~~~~~~~~~~~
A ``BooleanField`` indicating whether this tag should be protected from
deletion when the count reaches 0.
It also has several methods primarily for internal use, but some may be useful:
``get_related_objects()``
~~~~~~~~~~~~~~~~~~~~~~~~~
Return a list of instances of other models which refer to this tag; see
the API for more details
``update_count()``
~~~~~~~~~~~~~~~~~~
In case you're doing something weird which causes the count to get out
of sync, call this to update the count, and delete the tag if appropriate.
.. _tagmodel_merge_tags:
``merge_tags(tags)``
~~~~~~~~~~~~~~~~~~~~
Merge the specified tags into this tag.
``tags`` can be a queryset, list of tags or tag names, or a tag string.
.. _tagmodel_manager:
``tagulous.models.TagModelManager``
-----------------------------------
A ``TagModelManager`` is the standard manager for a :ref:`tagmodel`; it is a
subclass of the normal Django model manager, but its queries return a
:ref:`tagmodel_queryset` instead.
It also provides the following additional methods:
``filter_or_initial(...)``
~~~~~~~~~~~~~~~~~~~~~~~~~~
Calls the normal ``filter(...)`` method, but then adds on any initial tags
which may be missing.
.. _queryset_weight:
``weight(min=1, max=6)``
~~~~~~~~~~~~~~~~~~~~~~~~
Annotates a ``weight`` field to the tags. This is a weighted count between
the specified ``min`` and ``max``, which default to ``TAGULOUS_WEIGHT_MIN``
and ``TAGULOUS_WEIGHT_MAX`` (see :ref:`settings`).
This can be used to generate :ref:`tag clouds `, for example.
.. _tagmodel_queryset:
``tagulous.models.TagModelQuerySet``
------------------------------------
This is returned by the :ref:`tagmodel_manager`; it is a subclass of the normal
Django ``QuerySet`` class, but implements the same additional methods as the
``TagModelManager``.
.. _custom_tag_models:
Custom Tag Models
=================
A custom tag model should subclass ``tagulous.models.TagModel``, so that
Tagulous can find the fields and methods it expects, and so it uses the
appropriate tag model manager and queryset.
A custom tag model is a normal model in every other way, except it can have a
:ref:`tagmeta` class to define default options for the class.
There is :ref:`an example ` which illustrates how to
create a custom tag model.
If you want to use tag trees, you will need to subclass
``tagulous.models.TagTreeModel`` instead. The only difference is that
there will be extra fields on the model - see :doc:`tag_trees` for more
details.
.. _tagmeta:
TagMeta
-------
The ``TagMeta`` class is a container for tag options, to be used when creating
a custom tag model.
Set any :ref:`model_options` as class properties. When the model is created by
Python, the options will be available on the tag model class and tag fields
which use it as ``tag_options``.
Tag fields will not be able to override these options, and ``SingleTagField``
fields will ignore ``max_count``.
If ``tree`` is specified, it must be appropriate for the base class of the tag
model, eg if ``tree=True`` the tag model must subclass :ref:`tagtreemodel` -
but if it is not provided it will be set to the correct value.
``TagMeta`` can be inherited, so it can be set on abstract models. Options in
the ``TagMeta`` of a parent model can be overridden by options in the
``TagMeta`` of a child model.
Example::
import tagulous
class MyTagModel(tagulous.models.TagModel):
class TagMeta:
initial = 'judo, karate'
.. _protected_tags:
Protected tags
==============
The tag model keeps a count of how many times each tag is referenced. When the
tag count reaches ``0``, the tag will be deleted unless its ``protected`` field
is ``True``, or the ``protect_all`` option has been used.
.. note::
This only happens when the count is updated, ie when the tag is added
or removed; tags can therefore be created directly on the model with the
default count of ``0``, ready to be assigned later.
.. _command_initial_tags:
Loading initial tags
====================
Initial tags must be loaded using the ``initial_tags`` management command. You
can either load all initial tags in your site by not passing in any arguments,
or specify an app, model or field to load::
python manage.py initial_tags [[.[.]]]
* Tags which are new will be created
* Tags which have been deleted will be recreated
* Tags which exist will be untouched
django-tagulous-1.3.3/docs/models/tag_trees.rst 0000664 0000000 0000000 00000021072 14161666113 0021552 0 ustar 00root root 0000000 0000000 =========
Tag Trees
=========
Tags can be nested using tag trees for detailed categorisation, with tags
having parents, children and siblings.
Tags in tag trees denote parents using the forward slash character (``/``). For
example, ``Animal/Mammal/Cat`` is a ``Cat`` with a parent of ``Mammal`` and
grandparent of ``Animal``.
To use a slash in a tag name, escape it with a second slash; for example the
tag name ``Animal/Vegetable`` can be entered as ``Animal//Vegetable``.
A custom tag tree model must be a subclass of :ref:`tagtreemodel` instead of
the normal :ref:`tagmodel`; for automatically-generated tag models, this is
managed by setting the :ref:`option_tree` field option to ``True``.
Tag Tree Model Classes
======================
.. _tagtreemodel:
``tagulous.models.TagTreeModel``
--------------------------------
Because tree tag names are fully qualified (include all ancestors) and unique,
there is no difference to normal tags in how they are set or compared.
A ``TagTreeModel`` subclasses :ref:`tagmodel`; it inherits all the normal
fields and methods, and adds the following:
.. note::
Field values are computed and set automatically in the ``save()`` method -
so don't try to use them until the tag has been saved.
``parent``
~~~~~~~~~~
A ``ForeignKey`` to the parent tag. Tagulous sets this automatically when
saving, creating missing ancestors as needed.
``children``
~~~~~~~~~~~~
The reverse relation manager for ``parent``, eg ``mytag.children.all()``.
``label``
~~~~~~~~~
A ``CharField`` containing the name of the tag without its ancestors.
Example: a tag named ``Animal/Mammal/Cat`` has the label ``Cat``
``slug``
~~~~~~~~
A ``SlugField`` containing the slug for the tag label.
Example: a tag named ``Animal/Mammal/Cat`` has the slug ``cat``
.. _model_path:
``path``
~~~~~~~~
A ``TextField`` containing the path for this tag - this slug, plus all ancestor
slugs, separated by the ``/`` character, suitable for use in URLs. Tagulous
sets this automatically when saving.
Example: a tag named ``Animal/Mammal/Cat`` has the path ``animal/mammal/cat``
``level``
~~~~~~~~~
An ``IntegerField`` containing the level of this tag in the tree (starting from
1).
.. _tagtreemodel_merge_tags:
``merge_tags(tags, children=False)``
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Merge the specified tags into this tag.
``tags`` can be a queryset, list of tags or tag names, or a tag string.
If ``children=False``, only the specified tags will be merged; tagged items
will be reassigned to this tag, but if there are child tags they will not be
touched. If child tags do exist, although the merged tags' counts will be 0,
they will not be cleared.
If ``children=True``, child tags will be merged into children of this tag,
retaining structure; eg merging ``Pet`` into ``Animal`` will merge
``Pet/Mammal`` into ``Animal/Mammal``, ``Pet/Mammal/Cat`` into
``Animal/Mammal/Cat`` etc. Tags will be created if they don't exist.
``get_ancestors()``
~~~~~~~~~~~~~~~~~~~
Returns a queryset of all ancestors, ordered by level.
``get_descendants()``
~~~~~~~~~~~~~~~~~~~~~
Returns a queryset of all descendants, ordered by level.
``get_siblings()``
~~~~~~~~~~~~~~~~~~~~~
Returns a queryset of all siblings, ordered by name.
This includes the node itself; if you don't want it in the results, exclude it
afterwards, eg::
siblings = node.get_siblings().exclude(pk=node.pk)
.. _tagtreemodel_manager:
``tagulous.models.TagTreeModelManager``
---------------------------------------
A ``TagTreeModelManager`` is the standard manager for a :ref:`tagtreemodel`; it
is a subclass of :ref:`tagmodel_manager` so provides those methods, but its
queries return a :ref:`tagtreemodel_queryset` instead.
.. _tagtreemodel_queryset:
``tagulous.models.TagTreeModelQuerySet``
----------------------------------------
This is returned by the :ref:`tagtreemodel_manager`; it is a subclass of
:ref:`tagmodel_queryset` so provides those methods, but also:
``with_ancestors()``
~~~~~~~~~~~~~~~~~~~~
Returns a new queryset containing the nodes from the calling queryset, plus
their ancestor nodes.
``with_descendants()``
~~~~~~~~~~~~~~~~~~~~~~
Returns a new queryset containing the nodes from the calling queryset, plus
their descendant nodes.
``with_siblings()``
~~~~~~~~~~~~~~~~~~~
Returns a new queryset containing the nodes from the calling queryset, plus
theirm sibling nodes.
.. _converting_tag_trees:
Converting from to tree tags from normal tags
=============================================
When converting from a normal tag model to a tag tree model, you will need to
add extra fields. One of those (``path``) is a unique field, which means extra
steps are needed to build the migration.
These instructions will convert an existing ``TagModel`` to a ``TagTreeModel``.
Look through the code snippets and change the app and model names as
required:
1. Create a data migration to escape the tag names.
You can skip this step if you have been using slashes in normal tags and
want them to be converted to nested tree nodes.
Run ``manage.py makemigrations myapp --empty`` and add::
def escape_tag_names(apps, schema_editor):
model = apps.get_model('myapp', 'Tagulous_MyModel_Tags')
for tag in model.objects.all():
tag.name = tag.name.replace('/', '//')
tag.save()
operations = RunPython(escape_tag_names)
2. Create a schema migration to change the model fields. Because paths are not
allowed to be null, you need to add the ``path`` field as a non-unique
field, set some unique data on it (such as the object's ``pk``), and then
change the field to add back the unique constraint.
To do this reliably on all database types, see
`Migrations that add unique fields `_
in the official Django documentation.
If you are only working with databases which support transactions, you can
use a tagulous helper to add the unique field:
1. When you create the migration, Django will prompt you for a default value for the
unique ``path`` field; answer with ``'x'`` (do the same for the ``label`` field
when asked).
Change the new migration to use the Tagulous helper to add the ``path``
field.
2. Add the unique field::
import tagulous.models.migrations
...
class Migration(migrations.Migration):
# ... rest of Migration as generated
operations = [
...
# Leave other operations as they are, just replace AddField:
] + tagulous.models.migration.add_unique_field(
model_name='_tagulous_mymodel_tags',
name='path',
field=models.TextField(unique=True),
preserve_default=False,
set_fn=lambda obj: setattr(obj, 'path', str(obj.pk)),
) + [
...
]
.. warning::
Although ``add_unique_column`` and ``add_unique_field`` do work with
non-transactional databases, it is not without risk. See
:doc:`migrations` for more details.
3. We have changed the abstract base class of the tag model, but Django
migrations have no native way to do this. You will need to use the Tagulous
helper operation ``ChangeModelBases`` to do it manually, otherwise future
data migrations will think it is a ``TagModel``, not a ``TagTreeModel``.
Modify the migration from step 2; if you followed the official Django
documentation and have several migrations, modify the last one. Add the
``ChangeModelBases`` to the end of your ``operations`` list, as the last
operation::
import tagulous.models.migrations
class Migration(migrations.Migration):
# ... rest of Migration as generated
operations = [
# ... rest of operations
tagulous.models.migrations.ChangeModelBases(
name='_tagulous_mymodel_tags',
bases=(tagulous.models.models.BaseTagTreeModel, models.Model),
)
]
4. Create another data migration to rebuild the tag model and set the paths::
def rebuild_tag_model(apps, schema_editor):
model = apps.get_model('myapp', 'Tagulous_MyModel_Tags')
model.objects.rebuild()
operations = RunPython(rebuild_tag_model)
If you skipped step 1, this will also create and set parent tags as
necessary.
5. Run the migrations
You can see a working migration using steps 2 and 3 in the Tagulous tests, for
:source:`Django migrations `.
django-tagulous-1.3.3/docs/models/tagged_models.rst 0000664 0000000 0000000 00000014457 14161666113 0022404 0 ustar 00root root 0000000 0000000 =============
Tagged Models
=============
Models which have tag fields are called tagged models. In most situations, all
you need to do is add the tag field to the model and Tagulous will do the rest.
Because Tagulous's fields work by subclassing ``ForeignKey`` and
``ManyToManyField``, there are some places in Django's models where you would
expect to use tag strings but cannot - constructors and filtering, for example.
Tagulous therefore adds this functionality through the :ref:`taggedmodel` base class for tagged models.
If ``TAGULOUS_ENHANCE_MODELS = True`` (which it is by default - see
:ref:`settings`), this base class will be applied automatically, otherwise read
on to :ref:`taggedmanually`.
.. note::
Tagulous sets ``TaggedModel`` as the base class for your existing tagged
model by listening for the ``class_prepared`` signal, sent when a model has
been constructed. If the model contains tag fields, Tagulous will
dynamically add ``TaggedModel`` to the model's base classes and
``TaggedManager`` to the manager's base classes, which in turn adds
``TaggedQuerySet`` to the querysets the manager creates. It does this by
calling the ``cast_class`` class method on each of the base classes, which change the original classes in place.
This all happens seamlessly behind the scenes; the only thing you may
notice is that the names of your manager and queryset classes now have the
prefix ``CastTagged`` to indicate that they have been automatically cast to
their equivalents for tagged models.
Tagged model classes
====================
.. _taggedmodel:
``tagulous.models.TaggedModel``
-------------------------------
This is the base class for all tagged models. It changes the model constructor
so that ``TagField`` values can be passed as keywords.
.. _taggedmanager:
``tagulous.models.TaggedManager``
---------------------------------
The base class for managers of tagged models. It only exists to ensure querysets
are subclasses of ``tagulous.TaggedQuerySet``.
.. _taggedqueryset:
``tagulous.models.TaggedQuerySet``
----------------------------------
The base class for querysets on tagged models. It changes ``get``, ``filter`` and
``exclude`` to work with string values, and ``create`` and ``get_or_create`` to
work with string and ``TagField`` values.
It also adds ``get_similar_objects()`` - see :ref:`finding_similar_objects` for usage.
See :ref:`querying` for more details.
.. _taggedmanually:
Setting tagged base classes manually
====================================
However, if you want to avoid this automatic subclassing, you can set
``TAGULOUS_ENHANCE_MODELS = False`` and manage this yourself:
The three tagged base classes each have a class method ``cast_class`` which can
change existing classes so that they become ``CastTagged`` subclasses of
themselves; for example::
class MyModel(tagulous.TaggedModel):
name = models.CharField(max_length=255)
tags = tagulous.models.TagField()
objects = tagulous.models.TaggedManager.cast_class(MyModelManager)
other_manager = MyOtherManager
tagulous.models.TaggedManager.cast_class(MyModel.other_manager)
This can be useful when working with other third-party libraries which insist
on you doing things a certain way.
.. _querying:
Querying using tag fields
=========================
When querying a tagged model, remember that a ``SingleTagField`` is really a
``ForeignKey``, and a ``TagField`` is really a ``ManyToManyField``. You can
query using these relationships in conventional ways.
If you have correctly made your tagged model subclass :ref:`taggedmodel`, you
can also compare a tag field to a tag string in ``get``, ``filter`` and
``exclude``::
qs = MyModel.objects.get(name="Bob", title="Mr", tags="red, blue, green")
When querying a tag field, case sensitivity will default to whatever the tag
field option was. For example, if the ``title`` tag field above was defined
with ``case_sensitive=False``, ``.filter(title='Mr')`` will match ``Mr``,
``mr`` etc.
Note that when querying a ``TagField`` in this way, the returned queryset will
include (or exclude) any object which contains all the specified tags - but it
may also have other tags. To only return objects which have the specified tags
and no others, use the ``__exact`` field lookup suffix::
# Find all MyModel objects which have the tag 'red':
qs = MyModel.objects.filter(tags='red')
# (will include those tagged 'red, blue' etc)
# Find all MyModel objects which are only tagged 'red':
qs = MyModel.objects.filter(tags__exact='red')
# (will not include those tagged 'red, blue')
This currently does not work across database relations; you will need to use
the ``name`` field on the tag model for those::
# Find
qs = MyRelatedModel.objects.filter(
foreign_model__tags__name__in=['red', 'blue', 'green'],
)
.. _filter_by_related:
Filtering tags by related model fields
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Because tag fields use standard database relationships, you can easily filter
the tags by other fields in your model.
For example, if your model ``Record`` has a ``tags`` TagField and an ``owner``
foreign key to ``auth.User``, to get a list of tags which that user has used::
myobj.tags.tag_model.objects.filter(record__owner=user)
There is a ``filter_or_initial`` helper method on a ``TagModel``'s manager and
queryset, which will add initial tags to your filtered queryset::
myobj.tags.tag_model.objects.filter_or_initial(record__owner=user)
.. _finding_similar_objects:
Finding similar objects
~~~~~~~~~~~~~~~~~~~~~~~
The QuerySet on a tagged model provides the method ``get_similar_objects``, which takes
the instance and field name to compare similarity by, and returns a queryset of similar
objects from that tagged model, ordered by similarity::
myobj = MyModel.objects.first()
similar = MyModel.objects.get_similar_objects(myobj, 'tags')
There is a convenience wrapper on the related manager which detects the instance and
field to compare by::
similar = myobj.tags.get_similar_objects()
Although less useful, there is a similar function for single tag fields, which finds all
objects with the same tag::
similar = myobj.singletag.get_similar_objects()
The similar querysets will exclude the object being compared - in the above examples,
``myobj`` will not be in the queryset.
django-tagulous-1.3.3/docs/parser.rst 0000664 0000000 0000000 00000011721 14161666113 0017606 0 ustar 00root root 0000000 0000000 =================
Tag String Parser
=================
Tagulous model and form fields accept a tag string value - a list of tag names
separated by spaces or commas::
# These will parse to 'run', 'jump', 'hop'
'run jump hop'
'run,jump,hop'
If the tag string contains both spaces and commas, commas take priority. Spaces
at the start or end of a tag name are ignored by the parser::
# These will parse to 'run', 'shot put', 'hop'
# This is also how Tagulous will render these tags
'run, shot put, hop'
If a tag name contains a space or a comma it should be escaped by quote marks
for clarity, and will be when Tagulous renders the tag string::
# This is how Tagulous will render 'run', 'shot put'
'run, "shot put"'
Again, quoted tag names can be separated by spaces or commas, and commas take
priority::
# These will parse to 'run', 'shot put', 'hop'
'run "shot put" hop'
'run,"shot put",hop'
# But this will parse to 'run "shot put"' 'hop'
'run "shot put", hop'
If the tag model is a :doc:`tree `, the tag name is the full
path, which is split on the ``/`` character into a path of tag nodes; the tag
label is the final part of the path. The parser ignores a single slash if it
is escaped with another, ie ``slash//escaped``.
If the tag field has :ref:`option_space_delimiter` set to ``False`` then only
commas will be used to separate tags.
The parser is implemented in both Python and JavaScript for consistency.
For more examples and how the parser treats odd edge cases, see the examples
used for testing the parser in :source:`tests/test_utils.py` and
:source:`tests/spec/javascripts/tagulous.spec.js`.
Using the parser directly
=========================
Normally Tagulous uses the parser automatically behind the scenes when needed;
however, there may be times when you need to parse or render tag strings
manually - for example, when :ref:`converting_to_tagulous` or
:ref:`custom_autocomplete_adaptor`.
.. _python_parser:
In Python
---------
The python parser can be found in ``tagulous.utils``:
``tag_names = tagulous.utils.parse_tags(tag_string, max_count=0, space_delimiter=True)``
Given a tag string, returns a sorted list of unique tag names.
The parser does not attempt to enforce :ref:`option_force_lowercase` or
:ref:`option_case_sensitive` options - these should be applied before and
after parsing, respectively.
The optional ``max_count`` argument defaults to ``0``, which means no
limit. For any other value, if more tags are returned than specified, the
parser will raise a ``ValueError``.
The optional ``space_delimiter`` argument defaults to ``True``, to allow
either spaces or commas to be used as deliminaters to separate the tags,
with priority for commas. If ``False``, only commas will be used as the
delimiter.
``tag_string = tagulous.utils.render_tags(tag_names)``
Given a list of tags or tag names, generate a tag string.
``node_labels = tagulous.utils.split_tree_name(tag_name)``
Given a tree tag name, split it on valid ``/`` characters into a list of
labels for each node in the tag's path.
``tag_name = tagulous.utils.join_tree_name(parts)``
Given a list of node labels, return a tree tag name.
.. _javascript_parser:
In JavaScript
-------------
The JavaScript parser will normally be automatically added to the page by tag
fields, as one of the scripts in ``TAGULOUS_AUTOCOMPLETE_JS``
(see :ref:`settings`). However, if for some reason you want to use it without a
tag field, you can add it to your page manually with::
The parser adds the global variable ``Tagulous``:
``tagNames = Tagulous.parseTags(tagString, spaceDelimiter=true, withRaw=false)``
Given a tag string, returns a sorted list of unique tag names
If ``spaceDelimiter=false``, only commas will be used to separate tag
names. If it is unset or true, spaces are used as well as commas.
The option ``withRaw=true`` is intended for use when parsing live input;
the function will instead return ``[tags, raws]``, where ``tags`` is a
list of tags which is unsorted and not unique, and ``raws`` is a list of
raw strings which were left after the corresponding entry in ``tags`` was
parsed. For example::
var result = Tagulous.parseTags('one,two,three', true, true),
tags = result[0],
raws = parsed[1];
tags === ['one', 'two', 'three'];
raws === ['two,three', 'three', null];
If the last tag is not explicitly ended with a delimiter, the corresponding
item in ``raws`` will be ``null`` instead of an empty string, to indicate
that the parser unexpectedly ran out of characters.
This is useful when parsing live input if the last item in ``raws`` is an
empty string the tag has bee closed; if it is ``null`` then the tag is
still being entered.
``tagString = Tagulous.renderTags(tagNames)``
Given a list of tag names, generate a tag string.
django-tagulous-1.3.3/docs/tag_options.rst 0000664 0000000 0000000 00000025402 14161666113 0020641 0 ustar 00root root 0000000 0000000 ===========
Tag Options
===========
:ref:`Model options ` define how a tag model behaves. They can
either be set in the :ref:`model field arguments `, or
in the tag model's :ref:`tagmeta` class. Once defined, they are then stored in
a :ref:`TagOptions ` instance on the tag model, accessible at
``MyTagModel.tag_options`` (and shared with tag model fields at
``MyTaggedModel.tags.tag_options``).
Tagulous only lets you set options for a tag model in one place - if you use a
custom model you must set options using ``TagMeta``, and if you share an
auto-generated model between fields, only the first field can set options.
:ref:`Form options ` are a subset of the model options, and are
also used to control tag form fields, and are also stored in a ``TagOptions``
instance. If the field is part of a ``ModelForm`` it will inherit options from
the model, otherwise options can be passed in the field arguments.
.. _model_options:
Model Options
=============
The tag model options are:
.. _option_initial:
``initial``
-----------
List of initial tags for the tag model. Must be loaded into the database
with the management command :ref:`initial_tags `.
Value can be a tag string to be parsed, or an array of strings with one
tag in each string.
To change initial tags, you can change the ``initial`` option and re-run
the command :ref:`initial_tags `.
You should not find that you need to update ``initial`` regularly; if you
do, it would be better to use the Tagulous :doc:`admin tools ` to
add tags to the model directly.
If provided as a tag string, it will be parsed using spaces and commas,
regardless of the :ref:`option_space_delimiter` option.
Default: ``''``
.. _option_protect_initial:
``protect_initial``
-------------------
The ``protected`` state for any tags created by the ``initial`` argument -
see :ref:`protected_tags`.
Default: ``True``
.. _option_protect_all:
``protect_all``
---------------
Whether all tags with count 0 should be protected from automatic deletion.
If false, will be decided by ``tag.protected`` - see :ref:`protected_tags`.
Default: ``False``
.. _option_case_sensitive:
``case_sensitive``
------------------
If ``True``, tags will be case sensitive. For example, ``"django, Django"``
would be two separate tags.
If ``False``, tags will be capitalised according to the first time they are
used.
Note when using sqlite: substring matches on tag names, and matches on
tag names with non-ASCII characters, will never be case sensitive - see the
`databases `_
django documentation for more information.
See also :ref:`option_force_lowercase`
.. note::
MySQL struggles to offer string case sensitivity at the database level -
see the `django documentation `_
for more details. Tagulous therefore offers no formal support for this
option when running on MySQL - the relevant tests are bypassed, and you
should assume that ``case_sensitive`` is always ``False``. Patches welcome.
Default: ``False``
.. _option_force_lowercase:
``force_lowercase``
-------------------
Force all tags to lower case
Default: ``False``
.. _option_max_count:
``max_count``
-------------
``TagField`` only - this is not supported by ``SingleTagField``.
Specifies the maximum number of tags allowed.
Set to ``0`` to have no limit.
If you are setting it to ``1``, consider using a ``SingleTagField`` instead.
Default: ``0``
.. _option_space_delimiter:
``space_delimiter``
-------------------
``TagField`` only - this is not supported by ``SingleTagField``.
If ``True``, both commas and spaces can be used to separate tags. If ``False``,
only commas can be used to separate tags.
Default: ``True``
.. _option_tree:
``tree``
--------
Field argument only - this cannot be set in :ref:`tagmeta`
If ``True``, slashes in tag names will be used to denote children, eg
``grandparent/parent/child``, and these relationships can be traversed.
See :doc:`models/tag_trees` for more details.
If ``False``, slashes in tag names will have no significance, and no tree
properties or methods will be present on tag objects.
Default: ``False``
.. _option_autocomplete_initial:
``autocomplete_initial``
------------------------
If ``True``, override all other autocomplete settings and use the tags
defined in the ``initial`` argument for autocompletion, embedded in the
form field HTML.
For more advanced autocomplete filtering options (ie filter tags by user),
see the example :ref:`example_filter_related`.
Default: ``False``
.. _option_autocomplete_view:
``autocomplete_view``
---------------------
Specify the view to use for autocomplete queries.
This should be a value which can be passed to Django's ``reverse()``, eg the
name of the view.
If ``None``, all tags will be embedded into the form field HTML as the
``data-autocomplete`` attribute.
If this is an invalid view, a ``ValueError`` will be raised.
Default: ``None``
.. _option_autocomplete_view_args:
``autocomplete_view_args``
--------------------------
Optional ``args`` passed to the ``autocomplete_view``.
Default: ``None``
.. _option_autocomplete_view_kwargs:
``autocomplete_view_kwargs``
--------------------------
Optional ``kwargs`` passed to the ``autocomplete_view``.
Default: ``None``
.. _option_autocomplete_limit:
``autocomplete_limit``
----------------------
Maximum number of tags to provide at once, when ``autocomplete_view`` is
set.
If the autocomplete adaptor supports pages, this will be the number shown
per page, otherwise any after this limit will not be returned.
If ``0``, there will be no limit and all results will be returned
Default: ``100``
.. _option_autocomplete_view_fulltext:
``autocomplete_view_fulltext``
------------------------------
Whether to perform a start of word match (``__startswith``) or full text match
(``__contains``) in the autocomplete view.
Has no effect if not using ``autocomplete_view``.
Default: ``False`` (start of word)
.. _option_autocomplete_settings:
``autocomplete_settings``
-------------------------
Override the default ``TAGULOUS_AUTOCOMPLETE_SETTINGS``.
For example, the select2 control defaults to use the same width as the form element it
replaces; you can override this by passing their ``width`` option (see their docs on
`appearance `_) as an autocomplete setting::
myfield = TagField(... autocomplete_settings={"width": "75%"})
Default: ``None``
.. _option_get_absolute_url:
``get_absolute_url``
--------------------
A shortcut for defining a ``get_absolute_url`` method on the tag model.
Only used when defined in tag fields which auto-generate models.
It is common to need to get a URL for a tag, so rather than converting your tag
field to use a custom ``TagModel`` just to implement a ``get_absolute_url``
method, you can pass this argument a callback function.
The callback function will be passed the tag object, and should return the
URL for the tag. See the :ref:`example_tag_url` example for a simple lambda
argument.
If not set, the method ``get_absolute_url`` will not be available and an
``AttributeError`` will be raised.
.. note::
Due to the way Django migrations freeze model fields, this attribute is not
available during data migrations. See :ref:`migrations_limitations` for
more information.
Default: ``None``
.. _option_verbose_name:
``verbose_name_singular``, ``verbose_name_plural``
--------------------------------------------------
When a tag model is auto-generated from a field, it is given a
``verbose_name`` based on the tagged model's name and the tag field's
name; the ``verbose_name_plural`` is the same, but with an added ``s``
at the end. This is primarily used in the admin.
However, this will sometimes not make grammatical sense; these two
arguments can be used to override the field name component of the model
name.
The ``verbose_name_singular`` will usually be used with a ``TagField`` -
for example, the auto-generated model for ``MyModel.tags`` will have the
singular name ``My model tags``; this can be corrected by setting
``verbose_name_singular="tag"`` in the field definition.
The ``verbose_name_plural`` will usually be used with a ``SingleTagField`` -
for example, the auto-generated model for ``MyModel.category`` will have the
plural name ``My model categorys``; this can be corrected by setting
``verbose_name_plural="categories"`` in the field definition.
If one or both of these are not set, Tagulous will try to find the field
name from its ``verbose_name`` argument, falling back to the field name.
.. note::
When Tagulous automatically generates verbose names, it intentionally
performs no checks on how long they will be. When Django attempts to create
permissions for the model, if the generated verbose name is longer than 39
characters, it may raise a ``ValidationError``. To resolve this, set
``verbose_name_singular`` to a string which is 38 characters or less.
.. _form_options:
Form Options
============
The following options are used by form fields:
* :ref:`option_case_sensitive`
* :ref:`option_force_lowercase`
* :ref:`option_max_count`
* :ref:`option_tree`
* :ref:`option_autocomplete_limit`
* :ref:`option_autocomplete_settings`
.. _tagoptions:
The TagOptions Class
====================
The ``TagOptions`` class is a simple container for tag options. The options for
a model field are available from the ``tag_options`` property of unbound
:ref:`model_singletagfield` or :ref:`model_tagfield` fields.
All options listed in :ref:`model_options` are available directly on the
object, except for ``to``. It also provides two instance methods:
``items(with_defaults=True)``
Get a dict of all options
If with_defaults is true, any missing settings will be taken from the
defaults in ``constants.OPTION_DEFAULTS``.
``form_items(with_defaults=True)``
Get a dict of just the options for a form field.
If with_defaults is true, any missing settings will be taken from the
defaults in ``constants.OPTION_DEFAULTS``.
Example::
initial_tags = MyModel.tags.tag_options.initial
if "force_lowercase" in MyModel.tags.tag_options.items():
...
``TagOptions`` instances can be added together to create a new merged set of
options; note though that this is a shallow merge, ie the value of
``autocomplete_settings`` on the left will be replaced by the value on the
right::
merged_options = TagOptions(
autocomplete_settings={'width': 'resolve'}
) + TagOptions(
autocomplete_settings={'allowClear': True}
)
# merged_options.autocomplete_settings == {'allowClear': True}
In the same way, setting ``autocomplete_settings`` on the field will replace
any default value.
django-tagulous-1.3.3/docs/upgrading.rst 0000664 0000000 0000000 00000026374 14161666113 0020304 0 ustar 00root root 0000000 0000000 =========
Upgrading
=========
This document details breaking changes between versions, with any necessary steps to
safely upgrade.
For an overview of what has changed between versions, see the :doc:`changelog`.
Instructions
============
Tagulous follows semantic versioning in the format ``BREAKING.FEATURE.BUG``:
* Read the upgrade notes for a ``BREAKING`` release to see if you need to take
further action when upgrading.
* ``FEATURE`` and ``BUG`` releases will be safe to install without reading the upgrade
notes.
1. Check which version of Tagulous you are upgrading from::
python
>>> import tagulous
>>> tagulous.__version__
2. Upgrade the Tagulous package::
pip install --upgrade django-tagulous
3. Scroll down to the earliest instructions relevant to your version, and
follow them up to the latest version.
.. _upgrade_1-1-0:
Upgrading from 1.1.0
---------------------
Slugify behaviour
~~~~~~~~~~~~~~~~~
In Tagulous 1.2.0 the slugify logic has been replaced with Django's now all supported
Django versions support the ``allow_unicode`` slugify option.
If unicode tag slugs are not enabled with ``TAGULOUS_SLUG_ALLOW_UNICODE``
:ref:`setting `, Django's implementation of unicode to ASCII does not support
logographic characters, so these will be stripped as per Django's standard ``slugify()``
output, rather than Tagulous' old behaviour of replacing them with underscore
characters. This can now lead to empty slugs, which will now default to a single
underscore.
As a result of this change, the optional dependency ``unidecode`` and its corresponding
extra installation requirements ``[i18n]`` have been removed.
.. _upgrade_0-14-1:
Upgrading from 0.14.1
---------------------
Django and Python support
~~~~~~~~~~~~~~~~~~~~~~~~~
Tagulous 0.14.1 was the last version to support Django 1.10 and earlier.
Tagulous 1.0.0 requires Django 1.11 or later, and Python 2.7 or 3.5 or later.
Autocomplete upgrade
~~~~~~~~~~~~~~~~~~~~
Tagulous 1.0.0 changes the default JavaScript adaptor to use select2 v4. This may
necessitate some styling changes on your user-facing pages if you have overridden the
default styles.
Single tag behaviour
~~~~~~~~~~~~~~~~~~~~
Tagulous 1.0.0 no longer allows whitespace tags in ``SingleTagField``.
.. _upgrade_0-14-0:
Upgrading from 0.14.0
---------------------
Tagulous 0.14.0 was the last version to officially support Django 1.10 or
earlier.
.. _upgrade_0-13-0:
Upgrading from 0.13.0
---------------------
1. Setting ``null`` in a model ``TagField`` has raised a warning in the
parent ``ManyToManyField`` since Django 1.9. The warning now correctly
blames a ``TagField`` instead. The ``null`` argument in a model ``TagField``
is deprecated and has no effect, so should not be used.
2. Version 0.13.1 reduces support for Python 3.3. No known breaking changes
have been introduced, but this version of Python will no longer be tested
against due to lack of support in third party tools.
.. _upgrade_0-12-0:
Upgrading from 0.12.0
---------------------
1. Auto-generated tag models have been renamed.
Django 1.11 introduced a rule that models cannot start with an underscore.
Prior to this, Tagulous auto-generated tag models started ``_Tagulous_``, to
indicate they are auto-generated. From now on, they will start
``Tagulous_``.
Django migrations should detect this model name change::
./manage.py makemigrations
Did you rename the myapp._Tagulous_MyModel model to Tagulous_MyModel? [y/N]
Answer `y` for all Tagulous auto-generated models, and migrate::
./manage.py migrate
Troubleshooting:
* If you do not see the rename prompt when running ``makemigrations``, you
will need to edit the migration manually - see
`RenameModel `
in the Django documentation for more details.
* If any ``AlterField`` changes to the ``SingleTagField`` or ``TagField``
definitions are included in this set of migrations, the new tag model's
name will not be correctly detected and you will see the errors
``Related model ... cannot be resolved`` or ``AttributeError: 'TagField'
object has no attribute 'm2m_reverse_field_name'``. To resolve these,
manually change the ``to`` parameter in your ``AlterField``'s tag field definition from ``myapp._Tagulous_...`` to ``myapp.Tagulous_...``.
* If you see an error ``Renaming the table while in a transaction is not supported
because it would break referential integrity``, add ``atomic = False`` to your
migration class.
2. Version 0.13.0 reduces support for Django 1.4 and Python 3.2. No known
breaking changes have been introduced, but these versions of Django and
Python will no longer be tested against due to lack of support in third
party tools.
3. The ``TagField`` manager's ``__len__`` has now been removed, following its
deprecation in 0.12.0. If you are currently using ``len(instance.tagfield)``
then you should switch to using ``instance.tagfield.count()`` instead (see
:ref:`upgrade instructions `).
.. _upgrade_0-11-1:
Upgrading from 0.11.1
---------------------
1. Starting with version 0.12.0, Tagulous no longer enforces uniqueness for
tree ``path`` fields. This means that Django will detect a change to your
models, and warn you that your migrations are out of sync. It is safe for
you to create and apply a standard migration with::
./manage.py makemigrations
./manage.py migrate
This change is to avoid MySQL (and possibly other databases) from the errror
``"BLOB/TEXT column 'path' used in key specification without a key length"``
- see https://github.com/radiac/django-tagulous/issues/1 for discussion.
2. Version 0.12.0 deprecates the model tag manager's `__len__` method in
preparation for merging https://github.com/radiac/django-tagulous/pull/10
to resolve https://github.com/radiac/django-tagulous/issues/9.
If you are currently using `len(instance.tagfield)` then you should switch
to using `instance.tagfield.count()` instead.
.. _upgrade_0-9-0:
Upgrading from 0.9.0
--------------------
1. Starting with version 0.10.0, Tagulous is available on pypi. You can
continue to run the development version direct from github, but if you would
prefer to use stable releases you can reinstall::
pip uninstall django-tagulous
pip install django-tagulous
2. Version 0.10.0 adds ``label`` and ``level`` fields to the ``TagTreeModel``
base class (they were previously properties). This means that each of your
tag tree models will need a schema and data migration.
The schema migration will require a default value for the label; enter any
valid string, eg ``'.'``
The data migration will need to call ``mytagtreemodel.objects.rebuild()`` to
set the correct values for ``label`` and ``level``.
You will need to create and apply these migrations to each of your tag tree
models
Django migrations::
python manage.py makemigrations myapp
python manage.py migrate myapp
python manage.py makemigrations myapp --empty
# Add data migration operation below
python manage.py migrate myapp
Your Django data migration should include::
def rebuild_tree(apps, schema_editor):
# For an auto-generated tag tree model:
model = apps.get_model('myapp', '_Tagulous_MyModel_tagtreefield')
# For a custom tag tree model:
#model = apps.get_model('myapp', 'MyTagTreeModel')
model.objects.rebuild()
class Migration(migrations.Migration):
# ... rest of Migration as generated
operations = [
migrations.RunPython(rebuild_tree)
]
South migrations::
python manage.py schemamigration --auto myapp
python manage.py migrate myapp
python manage.py datamigration myapp upgrade_trees
# Add data migration function below
python manage.py migrate myapp
Your South data migration function should be::
def forwards(self, orm):
# For an auto-generated tag tree model:
model = orm['myapp._Tagulous_MyModel_tagtreefield'].objects.rebuild()
# For a custom tag tree model:
#model = orm['myapp.MyTagTreeModel'].objects.rebuild()
3. Since version 0.10.0 :ref:`option_tree` cannot be set in :ref:`tagmeta`;
custom tag models must get their tree status from their base class.
4. In version 0.10.0, ``TagOptions.field_items`` was renamed to
``TagOptions.form_items``, and ``constants.FIELD_OPTIONS`` was renamed to
``constants.FORM_OPTIONS``. These were internal, so should not affect your
code.
5. The tag parsers now accept a new argument to control whether space is used
as a delimiter or not. These are internal, so should not affect your code,
unless you have written a custom adaptor.
.. _upgrade_0-8-0:
Upgrading from 0.8.0
--------------------
1. Since 0.9.0, ``SingleTagField`` and ``TagField`` raise an exception if the
tag model isn't a subclass of TagModel.
2. The documentation for ``tagulous.models.migrations.add_unique_column`` has
been clarified to illustrate the risk of using it with a non-transactional
database. If you use this in your migrations, read the documentation to be
sure you understand the problem involved.
.. _upgrade_0-7-0:
Upgrading from 0.7.0 or earlier
-------------------------------
1. ``tagulous.admin.tag_model`` was deprecated in 0.8.0 and removed in 0.9.0;
use ``tagulous.admin.register`` instead::
tagulous.admin.tag_model(MyModel.tags)
tagulous.admin.tag_model(MyModel.tags, my_admin_site)
# becomes:
tagulous.admin.register(MyModel.tags)
tagulous.admin.register(MyModel.tags, site=my_admin_site)
2. Since 0.8.0, a ``ValueError`` exception is raised if a tag model field
definition specifies both a tag model and tag options.
For custom tag models, tag options must be set by adding a ``class TagMeta``
to your model. You can no longer set tag options in the tag field.
Where an auto-generated tag model is shared with another tag field, the
first tag field must set all tag options.
3. Any existing South migrations with ``SingleTagField`` or ``TagField``
definitions which automatically generate their tag models will need to be
manually modified in the ``Migration.models`` definition to have the
attribute ``'_set_tag_meta': 'True'``. For example, the line::
'labels': ('tagulous.models.fields.TagField', [], {'force_lowercase': 'True', 'to': u"orm['myapp._Tagulous_MyModel_labels']", 'blank': 'True'}),
becomes::
'labels': ('tagulous.models.fields.TagField', [], {'force_lowercase': 'True', 'to': u"orm['myapp._Tagulous_MyModel_labels']", 'blank': 'True', '_set_tag_meta': 'True'}),
Any `db.add_column` calls will need to be changed too::
db.add_column(u'myapp_mymodel', 'singletag',
self.gf('tagulous.models.fields.SingleTagField')(null=True, ...),
...)
becomes::
db.add_column(u'myapp_mymodel', 'singletag',
self.gf('tagulous.models.fields.SingleTagField')(_set_tag_meta=True, null=True, ...),
...)
This will use the keyword tag options to update the tag model's objects,
rather than raising the new ``ValueError``.
django-tagulous-1.3.3/docs/usage.rst 0000664 0000000 0000000 00000031555 14161666113 0017425 0 ustar 00root root 0000000 0000000 =============
Example Usage
=============
This section contains code examples of how to set up and use Tagulous. If you'd
like a more interactive demonstration, there is a
`static demo `_ showing the
front-end, or an
`example project `_
for you to install locally and play with some of these code examples.
.. _example_auto_tagmodel:
Automatic tag models
====================
This simple example creates a ``SingleTagField`` (a glorified ``ForeignKey``)
and two ``TagField`` (a typical tag field, using ``ManyToManyField``)::
from django.db import models
import tagulous.models
class Person(models.Model):
title = tagulous.models.SingleTagField(
label="Your preferred title",
initial="Mr, Mrs, Ms",
)
name = models.CharField(max_length=255)
skills = tagulous.models.TagField(
force_lowercase=True,
max_count=5,
)
* This will create two new models at runtime to store the tags,
``Tagulous_Person_title`` and ``Tagulous_Person_skills``.
* These models will act like normal models, and can be managed in the database
using Django migrations
* ``Person.title`` will now act as a ``ForeignKey`` to
``Tagulous_Person_title``
* ``Person.skills`` will now act as a ``ManyToManyField`` to
``Tagulous_Person_skills``
Initial tags need to be loaded into the database with the
:ref:`command_initial_tags` management command.
You can use the fields to assign and query values::
# Person.skills.tag_model == Tagulous_Person_skills
# Set tags on an instance with a string
instance = Person()
instance.skills = 'run, "kung fu", jump'
# They're not committed to the database until you save
instance.save()
# Get a list of all tags
tags = Person.skills.tag_model.objects.all()
# Assign a list of tags
instance.skills = ['jump', 'kung fu']
# Tags are readable before saving
# str(instance.skills) == 'jump, "kung fu"'
instance.save()
# Step through the list of instances in the tag model
for skill in instance.skills.all():
do_something(skill)
# Compare tag fields
if instance.skills == other.skills:
return True
.. _example_custom_tag_model:
Custom models
=============
You can create a tag model manually, and specify it in one or more tag fields::
import tagulous.models
class Hobbies(tagulous.models.TagModel):
class TagMeta:
# Tag options
initial = "eating, coding, gaming"
force_lowercase = True
autocomplete_view = 'myapp.views.hobbies_autocomplete'
class Person(models.Model):
name = models.CharField(max_length=255)
hobbies = tagulous.models.TagField(to=Hobbies)
Options for a custom tag model must be set in :ref:`tagmeta` - you cannot
pass them as arguments in tag fields.
See :doc:`models/tag_models` to see which field names Tagulous uses internally.
.. _example_tag_trees:
Tag Trees
=========
A tag field can specify ``tree=True`` to use slashes in tag names to denote
children::
import tagulous.models
class Person(models.Model):
name = models.CharField(max_length=255)
skills = tagulous.models.TagField(
force_lowercase=True,
max_count=5,
tree=True,
)
This can't be set in the tag model's ``TagMeta`` object; the tag model must
instead subclass :ref:`tagtreemodel`::
class Hobbies(tagulous.models.TagTreeModel):
class TagMeta:
initial = "food/eating, food/cooking, gaming/football"
force_lowercase = True
autocomplete_view = 'myapp.views.hobbies_autocomplete'
class Person(models.Model):
name = models.CharField(max_length=255)
hobbies = tagulous.models.TagField(to=Hobbies)
You can add tags as normal, and then query using tree relationships::
person.hobbies = "food/eating/mexican, sport/football"
person.save()
# Get all root nodes: "food", "gaming" and "sport"
root_nodes = Hobbies.objects.filter(parent=None)
# Get the direct children of food: "food/eating", "food/cooking"
food_children = Hobbies.objects.get(name="food").children.all()
# Get all descendants of food:
# "food/eating", "food/eating/mexican", "food/cooking"
food_children = Hobbies.objects.get(name="food").get_descendants()
See :doc:`models/tag_trees` to see a full list of available tree methods and
properties.
.. _example_tag_url:
Tag URL
=======
You can set the ``get_absolute_url`` tag option to a callable to give tag
objects absolute URLs without needing to create a custom tag model::
from django.db import models
from django.core.urlresolvers import reverse
import tagulous.models
class Person(models.Model):
name = models.CharField(max_length=255)
skills = tagulous.models.TagField(
get_absolute_url=lambda tag: reverse(
'myapp.views.by_skill', kwargs={'skill_slug': tag.slug}
),
)
The ``get_absolute_url`` method can now be called as normal; for example, from
a template::
{% for skill in person.skills.all %}
{{ skill.name }}
{% endfor %}
If you are using a tree, you will want to use the path instead::
skills = tagulous.models.TagField(
tree=True,
get_absolute_url=lambda tag: reverse(
'myapp.views.by_skill', kwargs={'skill_path': tag.path}
),
)
See the :ref:`option_get_absolute_url` option for more details.
.. _example_modelform:
ModelForms
==========
A ``ModelForm`` with tag fields needs no special treatment::
from django.db import models
from django import forms
import tagulous.models
class Person(models.Model):
name = models.CharField(max_length=255)
skills = tagulous.models.TagField()
class PersonForm(forms.ModelForm):
class Meta:
fields = ['name', 'skills']
model = Person
They are normal forms so can be used in normal ways; for example, with
class-based views::
from django.views.generic.edit import CreateView
class PersonCreate(CreateView):
model = Person
fields = ['name', 'skills']
or with view functions::
def person_create(request, template_name="my_app/person_form.html"):
form = PersonForm(request.POST or None)
if form.is_valid():
form.save()
return redirect('home')
return render(request, template_name, {'form': form})
However, because a ``TagField`` is based on a ``ManyToManyField``, if you save
your form using ``commit=False``, you will need to call ``save_m2m`` to save
the tags::
class Pet(models.Model):
owner = models.ForeignKey('auth.User')
name = models.CharField(max_length=255)
skills = tagulous.models.TagField()
class PetForm(forms.ModelForm):
class Meta:
fields = ['owner', 'name', 'skills']
model = Pet
def pet_create(request, template_name="my_app/pet_form.html"):
form = PetForm(request.POST or None)
if form.is_valid():
pet = form.save(commit=False)
pet.owner = request.user
# Next line will save all non M2M fields (including SingleTagField)
pet.save()
# Next line will save any ``TagField`` values
form.save_m2m()
return redirect('home')
return render(request, template_name, {'form': form})
As shown above, this only applies to ``TagField`` - a ``SingleTagField`` is
based on ``ForeignKey``, so will be saved without needing ``save_m2m``.
See :doc:`forms` for how to use tag fields in forms.
.. _example_form:
Forms without models
====================
Tagulous form fields take tag options as a single ``TagOptions`` object, rather
than as separate arguments as a model form does::
from django import forms
import tagulous.forms
class PersonForm(forms.ModelForm):
title = tagulous.forms.SingleTagField(
autocomplete_tags=['Mr', 'Mrs', 'Ms']
)
name = forms.CharField(max_length=255)
skills = tagulous.forms.TagField(
tag_options=tagulous.models.TagOptions(
force_lowercase=True,
),
autocomplete_tags=['running', 'jumping', 'judo']
)
A ``SingleTagField`` will return a string, and a ``TagField`` will return a
list of strings::
form = PersonForm(data={
'title': 'Mx',
'skills': 'Running, judo',
})
assert form.is_valid()
assert form.cleaned_data['title'] == 'Mx'
assert form.cleaned_data['skills'] == ['running', 'judo']
See :doc:`forms` for how to use tag fields in forms.
.. _example_filter_embedded:
Filtering embedded autocomplete
===============================
Filtering autocomplete to initial tags only
-------------------------------------------
If it often useful for autocomplete to only list your initial tags, and not
those added by others; Tagulous makes this easy with the
``autocomplete_initial`` field option::
class Person(models.Model):
title = tagulous.models.SingleTagField(
label="Your preferred title",
initial="Mr, Mrs, Ms",
autocomplete_initial=True,
)
Even if users add new tags, only the initial tags will ever be shown as
autocomplete options.
See :ref:`option_autocomplete_initial` for more details.
.. _example_filter_related:
Filtering autocomplete by related fields
----------------------------------------
This example will embed the tags into the HTML of the response; if you are
using autocomplete views, see :ref:`example_filter_autocomplete_view` instead.
Filter the ``autocomplete_tags`` queryset after the form initialises::
from django.db import models
from django import forms
import tagulous
class Pet(models.Model):
owner = models.ForeignKey('auth.User')
name = models.CharField(max_length=255)
skills = tagulous.models.TagField()
class PetForm(forms.ModelForm):
def __init__(self, user, *args, **kwargs):
super(PetForm, self).__init__(*args, **kwargs)
# Filter skills to initial skills, or ones added by this user
self.fields['skills'].autocomplete_tags = \
self.fields['skills'].autocomplete_tags.filter_or_initial(
pet__owner=user
).distinct()
class Meta:
model = Pet
Then call ``PetForm`` with the user as the first argument, for example::
def add_pet(request):
form = PetForm(request.user)
# ...
For more details, see :ref:`filter_by_related` and :ref:`filter_autocomplete`.
.. _example_autocomplete_views:
Autocomplete AJAX Views
=======================
To use AJAX to populate your autocomplete using JavaScript, set the tag option
``autocomplete_view`` in your models to a value for ``reverse()``::
class Person(models.Model):
name = models.CharField(max_length=255)
skills = tagulous.models.TagField(
autocomplete_view='person_skills_autocomplete'
)
You can then use the default autocomplete views directly in your urls::
import tagulous
from myapp.models import Person
urlpatterns = [
url(
r'^person/skills/autocomplete/',
tagulous.views.autocomplete,
{'tag_model': Person},
name='person_skills_autocomplete',
),
]
See :doc:`views` for more details.
.. _example_filter_autocomplete_view:
Filtering an autocomplete view
------------------------------
Add a wrapper function which filters the queryset before it calls the normal
``autocomplete`` view::
@login_required
def autocomplete_pet_skills(request):
return tagulous.views.autocomplete(
request,
Pet.skills.tag_model.objects.filter_or_initial(
pet__owner=user
).distinct()
)
Django REST Framework
=====================
The Django REST framework's ``ModelSerializer`` will serialize tag fields to their
primary keys; for example::
class PersonKeySerializer(ModelSerializer):
class Meta:
model = Person
fields = ["name", "title", "skills"]
person = Person.objects.create(name="adam", title="mr", skills="run, jump")
PersonKeySerializer(Person).data == {
"name": "adam",
"title": 1,
"skills": [1, 2]
If you'd prefer to serialize to strings, use the Tagulous ``TagSerializer``::
from tagulous.contrib.drf import TagSerializer
class PersonStringSerializer(TagSerializer):
class Meta:
model = Person
fields = ["name", "title", "skills"]
person = Person.objects.create(name="adam", title="mr", skills="run, jump")
PersonStringSerializer(Person).data == {
"name": "adam",
"title": "mr",
"skills": ["run", "jump"]
django-tagulous-1.3.3/docs/views.rst 0000664 0000000 0000000 00000007034 14161666113 0017451 0 ustar 00root root 0000000 0000000 ===================
Views and Templates
===================
.. _form_media:
Form templates
==============
To render Tagulous fields in forms outside the admin site, add ``{{ form.media }}`` to
your template to include the JavaScript and CSS resources; for example::
{% block content %}
{{ form.media }}
{{ form }}
{% endblock %}
For an example of adding the JavaScript and CSS separately, see the
`example project templates`__
__ https://github.com/radiac/django-tagulous/tree/develop/example/example/templates
.. _autocomplete_views:
Autocomplete views
==================
Although Tagulous doesn't need any views by default, it does provide generic
views in :source:`tagulous/views.py` to support AJAX autocomplete requests.
``response = autocomplete(request, tag_model)``
This takes the request object from the dispatcher, and a reference to the
tag model which this is autocompleting.
You can also pass in a QuerySet of the tag model, instead of the tag model
itself, in order to filter the tags which will be returned.
It returns an ``HttpResponse`` with content type ``application/json``. The
response content is a JSON-encoded object with one key, ``results``, which
is a list of tags.
``response = autocomplete_login(request, tag_model)``
Same as ``autocomplete``, except is decorated with Django auth's
``login_required``.
These views look for two GET parameters:
``q``
A query string to filter results by - used to match against the start of
the string.
Note: if using a sqlite database, matches on a case sensitive tag model
may not be case sensitive - see the
:ref:`option_case_sensitive` option for more details.
``p``
The page number to return, if :ref:`option_autocomplete_limit` is set on
the tag model.
Default: ``1``
For an example, see the :ref:`example_autocomplete_views` example.
.. _tag_clouds:
Tag clouds
==========
Tag clouds are a common way to display tags. Rather than have a template tag
with templates and options for every eventuality, Tagulous simply offers a
:ref:`weight() ` method on tag querysets, which adds a
``weight`` annotation to tag objects::
# myapp/view.py
def tag_cloud(request):
...
tags = MyModel.tags.tag_model.objects.weight()
...
The ``weight`` value will be a number between ``TAGULOUS_WEIGHT_MIN`` and
``TAGULOUS_WEIGHT_MAX`` (see :ref:`settings`), although these can be overridden
by passing arguments to ``weight()`` for new min and/or max values, eg::
tags = TagModel.objects.weight(min=2, max=4)
You can then render the tag cloud in your template as any other queryset, with
complete control over how they are displayed::
{% if tags %}
Tags
{% for tag in tags %}
{{ tag.name }}
{% endfor %}
{% endif %}
In that example, you would then define CSS classes for ``tag_1`` to ``tag_6``,
which set the appropriate font styles.
If you wanted to insert the tag cloud on every page, it would be easy to wrap
up in a custom template tag::
# myapp/templatetags/myapp_tagcloud.py
from django import template
from myapp import models
register = template.Library()
@register.inclusion_tag('myapp/include/tagcloud.html')
def show_results(poll):
tags = models.MyModel.tags.tag_model.objects.weight()
return {'tags': tags}
# myapp/templates/tagcloud.html - see template example above
django-tagulous-1.3.3/example/ 0000775 0000000 0000000 00000000000 14161666113 0016261 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/example/README.rst 0000664 0000000 0000000 00000001430 14161666113 0017746 0 ustar 00root root 0000000 0000000 ===================================
Example project for django-tagulous
===================================
This example project is configured for Django 3.2; Python 3.9 recommended.
You can see a static demo version of this example app at http://radiac.net/projects/django-tagulous/demo/
To set it up and run the live version in a self-contained virtualenv::
virtualenv tagulous-example
cd tagulous-example
source bin/activate
pip install "Django~=3.2"
pip install -e git+https://github.com/radiac/django-tagulous.git#egg=django-tagulous
cd src/django-tagulous/example
python manage.py migrate
python manage.py createsuperuser
python manage.py initial_tags
python manage.py runserver
You can then visit the example site at http://localhost:8000/
django-tagulous-1.3.3/example/example/ 0000775 0000000 0000000 00000000000 14161666113 0017714 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/example/example/__init__.py 0000664 0000000 0000000 00000000000 14161666113 0022013 0 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/example/example/admin.py 0000664 0000000 0000000 00000002115 14161666113 0021355 0 ustar 00root root 0000000 0000000 from django.contrib import admin
import tagulous.admin
from example import models
# Register the Person with a custom ModelAdmin
class PersonAdmin(admin.ModelAdmin):
list_display = ("name", "title", "skills", "hobbies")
list_filter = ("name", "title", "skills", "hobbies")
fieldsets = (
(
None,
{"fields": ("name",)},
),
(
"Feed",
{
"classes": ("collapse",),
"fields": (
"title",
"skills",
"hobbies",
),
},
),
)
tagulous.admin.register(models.Person, PersonAdmin)
# Auto-gen the ModelAdmins for skills and hobbies
tagulous.admin.register(models.Skill)
tagulous.admin.register(models.Person.hobbies.tag_model)
# Give the Title ModelAdmin the people as inlines
class PersonInline(admin.TabularInline):
model = models.Person
extra = 1
class TitleAdmin(admin.ModelAdmin):
inlines = [PersonInline]
tagulous.admin.register(models.Person.title.tag_model, TitleAdmin)
django-tagulous-1.3.3/example/example/forms.py 0000664 0000000 0000000 00000000347 14161666113 0021420 0 ustar 00root root 0000000 0000000 """
Forms for example Tagulous app
"""
from django import forms
from example import models
class PersonForm(forms.ModelForm):
class Meta:
fields = ["name", "title", "skills", "hobbies"]
model = models.Person
django-tagulous-1.3.3/example/example/migrations/ 0000775 0000000 0000000 00000000000 14161666113 0022070 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/example/example/migrations/0001_initial.py 0000664 0000000 0000000 00000015605 14161666113 0024542 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
from django.db import migrations, models
import tagulous.models.fields
import tagulous.models.models
class Migration(migrations.Migration):
dependencies = []
operations = [
migrations.CreateModel(
name="_Tagulous_Person_hobbies",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("name", models.CharField(unique=True, max_length=255)),
("slug", models.SlugField()),
(
"count",
models.IntegerField(
default=0,
help_text="Internal counter of how many times this tag is in use",
),
),
(
"protected",
models.BooleanField(
default=False,
help_text="Will not be deleted when the count reaches 0",
),
),
],
options={"ordering": ("name",), "abstract": False},
bases=(tagulous.models.models.BaseTagModel, models.Model),
),
migrations.CreateModel(
name="_Tagulous_Person_title",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("name", models.CharField(unique=True, max_length=255)),
("slug", models.SlugField()),
(
"count",
models.IntegerField(
default=0,
help_text="Internal counter of how many times this tag is in use",
),
),
(
"protected",
models.BooleanField(
default=False,
help_text="Will not be deleted when the count reaches 0",
),
),
],
options={"ordering": ("name",), "abstract": False},
bases=(tagulous.models.models.BaseTagModel, models.Model),
),
migrations.CreateModel(
name="Person",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("name", models.CharField(max_length=255)),
(
"hobbies",
tagulous.models.fields.TagField(
force_lowercase=True,
initial="eating, coding, gaming",
to="example._Tagulous_Person_hobbies",
blank=True,
help_text="This field splits on spaces and commas",
_set_tag_meta=True,
),
),
],
options={"verbose_name_plural": "people"},
),
migrations.CreateModel(
name="Skill",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("name", models.CharField(unique=True, max_length=255)),
("slug", models.SlugField()),
(
"count",
models.IntegerField(
default=0,
help_text="Internal counter of how many times this tag is in use",
),
),
(
"protected",
models.BooleanField(
default=False,
help_text="Will not be deleted when the count reaches 0",
),
),
("path", models.TextField()),
(
"label",
models.CharField(
help_text="The name of the tag, without ancestors",
max_length=255,
),
),
(
"level",
models.IntegerField(
default=1, help_text="The level of the tag in the tree"
),
),
(
"parent",
models.ForeignKey(
related_name="children",
blank=True,
to="example.Skill",
null=True,
on_delete=models.CASCADE,
),
),
],
options={"ordering": ("name",), "abstract": False},
bases=(tagulous.models.models.BaseTagTreeModel, models.Model),
),
migrations.AddField(
model_name="person",
name="skills",
field=tagulous.models.fields.TagField(
to="example.Skill",
autocomplete_view="person_skills_autocomplete",
space_delimiter=False,
help_text="This field does not split on spaces",
_set_tag_meta=True,
initial="JavaScript/Angular.js, JavaScript/JQuery, Linux/nginx, Linux/uwsgi, Python/Django, Python/Flask",
tree=True,
),
),
migrations.AddField(
model_name="person",
name="title",
field=tagulous.models.fields.SingleTagField(
initial="eating, coding, gaming",
force_lowercase=True,
blank=True,
to="example._Tagulous_Person_title",
help_text="This is a SingleTagField - effectively a CharField with dynamic choices",
_set_tag_meta=True,
null=True,
on_delete=models.CASCADE,
),
),
migrations.AlterUniqueTogether(
name="_tagulous_person_title", unique_together=set([("slug",)])
),
migrations.AlterUniqueTogether(
name="_tagulous_person_hobbies", unique_together=set([("slug",)])
),
migrations.AlterUniqueTogether(
name="skill", unique_together=set([("slug", "parent")])
),
]
django-tagulous-1.3.3/example/example/migrations/0002_auto_20190224_0637.py 0000664 0000000 0000000 00000000674 14161666113 0025524 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("example", "0001_initial")]
atomic = False
operations = [
migrations.RenameModel(
old_name="_Tagulous_Person_hobbies", new_name="Tagulous_Person_hobbies"
),
migrations.RenameModel(
old_name="_Tagulous_Person_title", new_name="Tagulous_Person_title"
),
]
django-tagulous-1.3.3/example/example/migrations/0003_alter_person_title.py 0000664 0000000 0000000 00000001442 14161666113 0027003 0 ustar 00root root 0000000 0000000 # Generated by Django 3.2.6 on 2021-08-24 07:28
import django.db.models.deletion
from django.db import migrations
import tagulous.models.fields
class Migration(migrations.Migration):
dependencies = [
("example", "0002_auto_20190224_0637"),
]
operations = [
migrations.AlterField(
model_name="person",
name="title",
field=tagulous.models.fields.SingleTagField(
_set_tag_meta=True,
blank=True,
help_text="This is a SingleTagField - effectively a CharField with dynamic choices",
initial="Mr, Mrs",
null=True,
on_delete=django.db.models.deletion.CASCADE,
to="example.tagulous_person_title",
),
),
]
django-tagulous-1.3.3/example/example/migrations/__init__.py 0000664 0000000 0000000 00000000000 14161666113 0024167 0 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/example/example/models.py 0000664 0000000 0000000 00000002333 14161666113 0021552 0 ustar 00root root 0000000 0000000 """
Models for example Tagulous app
Based on the usage examples in the documentation:
http://radiac.net/projects/django-tagulous/documentation/usage/
"""
from django.db import models
import tagulous.models
class Skill(tagulous.models.TagTreeModel):
class TagMeta:
initial = [
"Python/Django",
"Python/Flask",
"JavaScript/JQuery",
"JavaScript/Angular.js",
"Linux/nginx",
"Linux/uwsgi",
]
space_delimiter = False
autocomplete_view = "person_skills_autocomplete"
class Person(models.Model):
name = models.CharField(max_length=255)
title = tagulous.models.SingleTagField(
initial="Mr, Mrs",
help_text=(
"This is a SingleTagField - effectively a CharField with " "dynamic choices"
),
on_delete=models.CASCADE,
)
skills = tagulous.models.TagField(
Skill, help_text="This field does not split on spaces"
)
hobbies = tagulous.models.TagField(
initial="eating, coding, gaming",
force_lowercase=True,
blank=True,
help_text="This field splits on spaces and commas",
)
class Meta:
verbose_name_plural = "people"
django-tagulous-1.3.3/example/example/settings.py 0000664 0000000 0000000 00000004444 14161666113 0022134 0 ustar 00root root 0000000 0000000 """
Django settings for example project.
"""
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
import os
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = "example-secret"
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = ["*"]
# Application definition
INSTALLED_APPS = (
"django.contrib.admin",
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"django.contrib.messages",
"django.contrib.staticfiles",
"tagulous",
"example",
)
MIDDLEWARE = (
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.common.CommonMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
"django.middleware.clickjacking.XFrameOptionsMiddleware",
"django.middleware.security.SecurityMiddleware",
)
ROOT_URLCONF = "example.urls"
TEMPLATES = [
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": ["templates"],
"APP_DIRS": True,
"OPTIONS": {
"context_processors": [
"django.template.context_processors.debug",
"django.template.context_processors.request",
"django.contrib.auth.context_processors.auth",
"django.contrib.messages.context_processors.messages",
]
},
}
]
WSGI_APPLICATION = "example.wsgi.application"
# Database
DATABASES = {
"default": {
"ENGINE": "django.db.backends.sqlite3",
"NAME": os.path.join(BASE_DIR, "db.sqlite3"),
}
}
# Internationalization
LANGUAGE_CODE = "en-us"
TIME_ZONE = "UTC"
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
STATIC_URL = "/static/"
DEFAULT_AUTO_FIELD = "django.db.models.AutoField"
# Tagulous configuration
SERIALIZATION_MODULES = {
"xml": "tagulous.serializers.xml_serializer",
"json": "tagulous.serializers.json",
"python": "tagulous.serializers.python",
"yaml": "tagulous.serializers.pyyaml",
}
django-tagulous-1.3.3/example/example/templates/ 0000775 0000000 0000000 00000000000 14161666113 0021712 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/example/example/templates/base.html 0000664 0000000 0000000 00000004060 14161666113 0023512 0 ustar 00root root 0000000 0000000
{{ title }}
{% block css %}
{% endblock %}
{% block js %}
{% endblock %}
Admin siteTagulous site
{% endblock %}
django-tagulous-1.3.3/example/example/urls.py 0000664 0000000 0000000 00000000667 14161666113 0021264 0 ustar 00root root 0000000 0000000 from django.conf.urls import url
from django.contrib import admin
import tagulous.views
from . import models, views
urlpatterns = [
url(r"^admin/", admin.site.urls),
url(
r"^api/skills/$",
tagulous.views.autocomplete,
{"tag_model": models.Skill},
name="person_skills_autocomplete",
),
url(r"^$", views.index, name="index"),
url(r"^(?P\d+)/$", views.index, name="edit"),
]
django-tagulous-1.3.3/example/example/views.py 0000664 0000000 0000000 00000003160 14161666113 0021423 0 ustar 00root root 0000000 0000000 """
Views for Tagulous example app
"""
from django.contrib import messages
from django.http import HttpResponseRedirect
from django.shortcuts import render
from django.urls import reverse
from . import forms, models
def index(request, person_pk=None):
"""
Main demo page
"""
people = models.Person.objects.all()
titles = models.Person.title.tag_model.objects.all()
skills = models.Skill.objects.all()
hobbies = models.Person.hobbies.tag_model.objects.all()
if person_pk:
person = models.Person.objects.get(pk=person_pk)
submit_label = "Update"
else:
person = None
submit_label = "Add"
if request.POST:
person_form = forms.PersonForm(request.POST, instance=person)
if person_form.is_valid():
person = person_form.save()
messages.success(request, "Form saved as Person %d" % person.pk)
return HttpResponseRedirect(reverse(index))
else:
person_form = forms.PersonForm(instance=person)
return render(
request,
"example/index.html",
{
"title": "Django Tagulous Example",
"Person_name": models.Person.__name__,
"Title_name": models.Person.title.tag_model.__name__,
"Skill_name": models.Skill.__name__,
"Hobby_name": models.Person.hobbies.tag_model.__name__,
"people": people,
"titles": titles,
"hobbies": hobbies,
"skills": skills,
"person_form": person_form,
"form_media": person_form.media,
"submit_label": submit_label,
},
)
django-tagulous-1.3.3/example/example/wsgi.py 0000664 0000000 0000000 00000000443 14161666113 0021240 0 ustar 00root root 0000000 0000000 """
WSGI config for example project.
It exposes the WSGI callable as a module-level variable named ``application``.
"""
import os
from django.core.wsgi import get_wsgi_application
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "example.settings")
application = get_wsgi_application()
django-tagulous-1.3.3/example/manage.py 0000775 0000000 0000000 00000000373 14161666113 0020071 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import os
import sys
if __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "example.settings")
from django.core.management import execute_from_command_line
execute_from_command_line(sys.argv)
django-tagulous-1.3.3/requirements.test.txt 0000664 0000000 0000000 00000000227 14161666113 0021071 0 ustar 00root root 0000000 0000000 # Requirements for testing
pyyaml
djangorestframework~=3.0
pytest
pytest-pythonpath
pytest-black
pytest-cov
pytest-django
pytest-flake8
pytest-isort
django-tagulous-1.3.3/setup.cfg 0000664 0000000 0000000 00000003764 14161666113 0016461 0 ustar 00root root 0000000 0000000 [metadata]
name = django-tagulous
description = Fabulous Tagging for Django
long_description = file: README.rst
keywords = django tagging
author = Richard Terry
author_email = code@radiac.net
license = BSD
classifiers =
Development Status :: 5 - Production/Stable
Environment :: Web Environment
Framework :: Django
Framework :: Django :: 2.2
Framework :: Django :: 3.0
Framework :: Django :: 3.1
Framework :: Django :: 3.2
Framework :: Django :: 4.0
Intended Audience :: Developers
License :: OSI Approved :: BSD License
Operating System :: OS Independent
Programming Language :: Python
Programming Language :: Python :: 3
Programming Language :: Python :: 3 :: Only
Programming Language :: Python :: 3.6
Programming Language :: Python :: 3.7
Programming Language :: Python :: 3.8
Programming Language :: Python :: 3.9
url = https://radiac.net/projects/django-tagulous/
project_urls =
Documentation = https://radiac.net/projects/django-tagulous/documentation/
Source = https://github.com/radiac/django-tagulous
Tracker = https://github.com/radiac/django-tagulous/issues
[options]
python_requires = >=3.6
packages = find:
install_requires = Django>=2.2
include_package_data = true
zip_safe = false
[options.packages.find]
exclude =
tests*
docs*
[tool:pytest]
python_paths = .
testpaths = tagulous tests
addopts = --black --isort --flake8 --cov=tagulous --cov-report=term --cov-report=html --ignore-glob=tests/tagulous_tests_migration/migrations_*
django_find_project = false
DJANGO_SETTINGS_MODULE = tests.settings
[coverage:run]
parallel=True
[flake8]
ignore = E123,E128,E203,E501,W503
max-line-length = 88
exclude = .git,__pycache__,build,dist,.tox
[isort]
multi_line_output = 3
line_length = 88
known_django = django
known_first_party = tagulous
sections = FUTURE,STDLIB,DJANGO,THIRDPARTY,FIRSTPARTY,LOCALFOLDER
include_trailing_comma = True
lines_after_imports = 2
skip = .tox,.git
[doc8]
max-line-length = 88
ignore-path = *.txt,.tox
django-tagulous-1.3.3/setup.py 0000664 0000000 0000000 00000000602 14161666113 0016336 0 ustar 00root root 0000000 0000000 import re
from pathlib import Path
from setuptools import setup
def find_version(*paths):
path = Path(*paths)
content = path.read_text()
match = re.search(r"^__version__\s*=\s*['\"]([^'\"]*)['\"]", content, re.M)
if match:
return match.group(1)
raise RuntimeError("Unable to find version string.")
setup(version=find_version("tagulous", "__init__.py"))
django-tagulous-1.3.3/tagulous/ 0000775 0000000 0000000 00000000000 14161666113 0016471 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/tagulous/__init__.py 0000664 0000000 0000000 00000000274 14161666113 0020605 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
"""
Django Tagulous - Fabulous Tags
"""
__version__ = "1.3.3"
__license__ = "BSD"
__author__ = "Richard Terry"
default_app_config = "tagulous.apps.TagulousConfig"
django-tagulous-1.3.3/tagulous/admin.py 0000664 0000000 0000000 00000030333 14161666113 0020135 0 ustar 00root root 0000000 0000000 from django import forms
from django.contrib import admin, messages
from django.core.exceptions import ImproperlyConfigured
from django.db.models.base import ModelBase
from django.http import HttpResponseRedirect
from django.shortcuts import render
from . import forms as tag_forms
from . import models as tag_models
# ##############################################################################
# ########################################################## Admin classes
# ##############################################################################
class TaggedBaseModelAdminMixin(admin.options.BaseModelAdmin):
"""
Mixin for BaseModelAdmin subclasses which are for tagged models
"""
def formfield_for_dbfield(self, db_field, **kwargs):
"""
Remove the RelatedFieldWidgetWrapper from tag fields, so they don't
display popup buttons
"""
formfield = super(TaggedBaseModelAdminMixin, self).formfield_for_dbfield(
db_field, request=kwargs.pop("request", None), **kwargs
)
if (
isinstance(db_field, (tag_models.SingleTagField, tag_models.TagField))
and isinstance(formfield.widget, admin.widgets.RelatedFieldWidgetWrapper)
and isinstance(formfield.widget.widget, tag_forms.AdminTagWidget)
):
formfield.widget = formfield.widget.widget
return formfield
def get_autocomplete_fields(self, request):
"""
Ensure TagFields aren't listed in Django's autocomplete_fields - they don't
play well with Django's autocomplete, and will use their own
"""
autocomplete_fields = super().get_autocomplete_fields(request)
safe_fields = [
field
for field in autocomplete_fields
if not isinstance(
self.opts.get_field(field),
(tag_models.SingleTagField, tag_models.TagField),
)
]
return safe_fields
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# ModelAdmin for Tagged models
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
class TaggedModelAdmin(TaggedBaseModelAdminMixin, admin.ModelAdmin):
pass
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# ModelAdmin for TagModel models
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
class TagModelAdmin(admin.ModelAdmin):
list_display = ["name", "count", "protected"]
list_filter = ["protected"]
search_fields = ["name"]
exclude = ["count"]
actions = ["merge_tags"]
prepopulated_fields = {"slug": ("name",)}
def merge_tags(self, request, queryset):
"""
Admin action to merge tags
"""
# Thanks to:
# http://www.hoboes.com/Mimsy/hacks/django-actions-their-own-intermediate-page/
# Create a form
is_tree = issubclass(self.model, tag_models.TagTreeModel)
class MergeForm(forms.Form):
# Keep selected items in same field, admin.helpers.ACTION_CHECKBOX_NAME
_selected_action = forms.CharField(widget=forms.MultipleHiddenInput)
# Allow use to select from selected items
merge_to = forms.ModelChoiceField(queryset)
if is_tree:
class MergeForm(MergeForm):
# Allow to merge recursively
merge_children = forms.BooleanField(required=False)
if "merge" in request.POST:
merge_form = MergeForm(request.POST)
if merge_form.is_valid():
# Merge - with children if set
merge_to = merge_form.cleaned_data["merge_to"]
kwargs = {}
if is_tree and merge_form.cleaned_data["merge_children"]:
kwargs["children"] = True
merge_to.merge_tags(queryset, **kwargs)
self.message_user(request, "Tags merged", messages.SUCCESS)
return HttpResponseRedirect(request.get_full_path())
else:
tag_pks = request.POST.getlist(admin.helpers.ACTION_CHECKBOX_NAME)
if len(tag_pks) < 2:
self.message_user(
request,
"You must select at least two tags to merge",
messages.ERROR,
)
return HttpResponseRedirect(request.get_full_path())
merge_form = MergeForm(
initial={
admin.helpers.ACTION_CHECKBOX_NAME: request.POST.getlist(
admin.helpers.ACTION_CHECKBOX_NAME
),
"merge_children": True,
}
)
return render(
request,
"tagulous/admin/merge_tags.html",
{
"title": "Merge tags",
"opts": self.model._meta,
"merge_form": merge_form,
"tags": queryset,
},
)
merge_tags.short_description = "Merge selected tags..."
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# ModelAdmin for TagTreeModel models
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
class TagTreeModelAdmin(TagModelAdmin):
exclude = ["count", "parent", "path", "label", "level"]
# ##############################################################################
# ########################################################## Admin registration
# ##############################################################################
# Give contrib.admin a default widget for tag fields
admin.options.FORMFIELD_FOR_DBFIELD_DEFAULTS.update(
{
tag_models.SingleTagField: {"widget": tag_forms.AdminTagWidget},
tag_models.TagField: {"widget": tag_forms.AdminTagWidget},
}
)
def _create_display(field):
"""
ModelAdmin display function factory
"""
def display(self, obj):
return getattr(obj, field).get_tag_string()
display.short_description = field.replace("_", " ")
return display
def enhance(model, admin_class):
"""
Add tag support to the admin class based on the specified model
"""
#
# Get a list of all tag fields
#
# Dict of single tag fields, {name: tag}
single_tag_fields = {}
# Dict of normal tag fields, {name: tag}
tag_fields = {}
# List of all single and normal tag fields
tag_field_names = []
# Check for SingleTagField related fields
for field in tag_models.singletagfields_from_model(model):
single_tag_fields[field.name] = field
tag_field_names.append(field.name)
# Check for TagField m2m fields
for field in tag_models.tagfields_from_model(model):
tag_fields[field.name] = field
tag_field_names.append(field.name)
#
# Ensure any tag fields in list_display are rendered by functions
#
# The admin.site.register will complain if it's a ManyToManyField, so this
# will work around that.
#
# We also need to have a different name to the model field, otherwise the
# ChangeList class will just use the model field - that would get the tag
# strings showing in the table, but the column would be sortable which
# would cause problems for TagFields, and the display function would never
# get called, which would be unexpected for anyone maintaining this code.
if hasattr(admin_class, "list_display"):
# Make sure we're working with a list
if isinstance(admin_class.list_display, tuple):
admin_class.list_display = list(admin_class.list_display)
for i, field in enumerate(admin_class.list_display):
# If the field's not a callable, and not in the admin class already
if not hasattr(field, "__call__") and not hasattr(admin_class, field):
# Only TagFields (admin can already handle SingleTagField FKs)
if field in tag_fields:
# Create new field name and replace in list_display
display_name = "_tagulous_display_%s" % field
admin_class.list_display[i] = display_name
# Add display function to admin class
setattr(admin_class, display_name, _create_display(field))
#
# If admin is for a tag model, ensure any inlines for tagged models are
# subclasses of TaggedInlineFormSet.
#
if issubclass(model, tag_models.BaseTagModel) and hasattr(admin_class, "inlines"):
for inline_cls in admin_class.inlines:
# Make sure inline class uses TaggedBaseModelAdminMixin
if not issubclass(inline_cls, TaggedBaseModelAdminMixin):
inline_cls.__bases__ = (
TaggedBaseModelAdminMixin,
) + inline_cls.__bases__
# Make sure inlines used TaggedInlineFormSet
if issubclass(inline_cls.model, tag_models.TaggedModel) and not issubclass(
inline_cls.formset, tag_forms.TaggedInlineFormSet
):
orig_cls = inline_cls.formset
inline_cls.formset = type(
str("Tagged%s" % orig_cls.__name__),
(tag_forms.TaggedInlineFormSet, orig_cls),
{},
)
def register(model, admin_class=None, site=None, **options):
"""
Provide tag support to the model when it is registered with the admin site.
For tagged models (have one or more SingleTagField or TagField fields):
* Admin will support TagField in list_display
For tag models (subclass of TagModel):
* Admin will provide a merge action to merge tags
For other models:
* No changes made
Arguments:
model Model to register
admin_class Admin class for model
site Admin site to register with
Default: django.contrib.admin.site
**options Extra options for admin class
This only supports one model, but is otherwise safe to use with non-tagged
models.
"""
# Look at the model we've been given
if isinstance(model, tag_models.BaseTagDescriptor):
# It's a tag descriptor; change it for the tag model itself
model = model.tag_model
elif not isinstance(model, ModelBase):
raise ImproperlyConfigured(
"Tagulous can only register a single model with admin."
)
# Ensure we have a valid admin site
if site is None:
site = admin.site
#
# Determine appropriate admin class
#
if not admin_class:
admin_class = admin.ModelAdmin
# Going to make a list of base classes to inject
cls_bases = []
# If it's a tag model, subclass TagModelAdmin or TagTreeModelAdmin
if issubclass(model, tag_models.BaseTagModel):
if issubclass(model, tag_models.TagTreeModel):
if not issubclass(admin_class, TagTreeModelAdmin):
cls_bases += [TagTreeModelAdmin]
else:
if not issubclass(admin_class, TagModelAdmin):
cls_bases += [TagModelAdmin]
# If it's a tagged model, subclass TaggedModelAdmin
singletagfields = tag_models.singletagfields_from_model(model)
tagfields = tag_models.tagfields_from_model(model)
if singletagfields or tagfields:
if not issubclass(admin_class, TaggedModelAdmin):
cls_bases += [TaggedModelAdmin]
# If options specified, or other bases, will need to subclass admin_class
if options or cls_bases:
cls_bases += [admin_class]
# Update options with anything the new subclasses could have overidden
# in a custom ModelAdmin - unless they're already overridden in options
options["__module__"] = __name__
if admin_class != admin.ModelAdmin:
options.update(
dict(
(k, v)
for k, v in admin_class.__dict__.items()
if k in ["list_display", "list_filter", "exclude", "actions"]
and k not in options
)
)
admin_class = type(str("%sAdmin" % model.__name__), tuple(cls_bases), options)
# Enhance the model admin class
enhance(model, admin_class)
# Register the model
# Don't pass options - we've already dealt with that
site.register(model, admin_class)
django-tagulous-1.3.3/tagulous/apps.py 0000664 0000000 0000000 00000000420 14161666113 0020002 0 ustar 00root root 0000000 0000000 from django.apps import AppConfig
class TagulousConfig(AppConfig):
name = "tagulous"
def ready(self):
from .checks import register_checks
from .signals.post import register_post_signals
register_checks()
register_post_signals()
django-tagulous-1.3.3/tagulous/checks.py 0000664 0000000 0000000 00000001546 14161666113 0020311 0 ustar 00root root 0000000 0000000 from django.core.checks import Warning, register
SERIALIZATION_MODULES_EXPECTED = {
"xml": "tagulous.serializers.xml_serializer",
"json": "tagulous.serializers.json",
"python": "tagulous.serializers.python",
"yaml": "tagulous.serializers.pyyaml",
}
WARNING_W001 = Warning(
"``settings.SERIALIZATION_MODULES`` has not been configured as expected",
hint=(
"See Tagulous installation instructions for"
" recommended SERIALIZATION_MODULES setting"
),
id="tagulous.W001",
)
def tagulous_check(app_configs, **kwargs):
from django.conf import settings
errors = []
serialization_modules = getattr(settings, "SERIALIZATION_MODULES", None)
if serialization_modules != SERIALIZATION_MODULES_EXPECTED:
errors.append(WARNING_W001)
return errors
def register_checks():
register(tagulous_check)
django-tagulous-1.3.3/tagulous/constants.py 0000664 0000000 0000000 00000002234 14161666113 0021060 0 ustar 00root root 0000000 0000000 """
Tagulous constants
"""
# Prefix for all models auto-generated by Tagulous
MODEL_PREFIX = "Tagulous"
# Attribute of manager on the tagged model
# %s will be replaced by the field name
TAGGED_ATTR_MANAGER = "_%s_tagulous"
# Constants to improve code legibility
COMMA = ","
SPACE = " "
QUOTE = '"'
DOUBLE_QUOTE = QUOTE + QUOTE
TREE = "/"
# Default model TagField options
OPTION_DEFAULTS = {
"initial": "",
"protect_initial": True,
"protect_all": False,
"case_sensitive": False,
"force_lowercase": False,
"max_count": 0,
"space_delimiter": True,
"tree": False,
"autocomplete_initial": False,
"autocomplete_view": "",
"autocomplete_view_args": None,
"autocomplete_view_kwargs": None,
"autocomplete_view_fulltext": False,
"autocomplete_limit": 100,
"autocomplete_settings": None,
"get_absolute_url": None,
"verbose_name_singular": None,
"verbose_name_plural": None,
}
# List of model TagField options which are relevant to form fields
FORM_OPTIONS = [
"case_sensitive",
"force_lowercase",
"max_count",
"space_delimiter",
"tree",
"autocomplete_limit",
"autocomplete_settings",
]
django-tagulous-1.3.3/tagulous/contrib/ 0000775 0000000 0000000 00000000000 14161666113 0020131 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/tagulous/contrib/__init__.py 0000664 0000000 0000000 00000000000 14161666113 0022230 0 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/tagulous/contrib/drf.py 0000664 0000000 0000000 00000003006 14161666113 0021255 0 ustar 00root root 0000000 0000000 from rest_framework import serializers
from rest_framework.fields import CharField, ListField
from ..models.fields import SingleTagField, TagField
class TagRelatedManagerField(ListField):
"""
Serialize a TagField to a list of strings
"""
def __init__(self, *args, **kwargs):
"""
Default the child to a CharField
"""
kwargs.setdefault("child", CharField(required=kwargs.get("required", False)))
super().__init__(*args, **kwargs)
def to_representation(self, data):
"""
List of object instances -> List of dicts of primitive datatypes.
"""
return [
self.child.to_representation(item) if item is not None else None
for item in data.all()
]
class TagSerializer(serializers.ModelSerializer):
"""
Serialize tag fields as strings
"""
def get_fields(self):
"""
Override field mappings to use string string serializers for tag fields
"""
field_mappings = super().get_fields()
fields = self.Meta.model._meta.get_fields()
for field in fields:
if field.name not in field_mappings:
continue
if isinstance(field, SingleTagField):
field_mappings[field.name] = CharField(required=field.required)
elif isinstance(field, TagField):
# M2M cannot have required=True
field_mappings[field.name] = TagRelatedManagerField(required=False)
return field_mappings
django-tagulous-1.3.3/tagulous/forms.py 0000664 0000000 0000000 00000030413 14161666113 0020172 0 ustar 00root root 0000000 0000000 import json
from django import forms
from django.contrib.admin.widgets import AutocompleteMixin
from django.core.serializers.json import DjangoJSONEncoder
from django.db.models.query import QuerySet
from django.urls import NoReverseMatch, reverse
from django.utils.encoding import force_str
from django.utils.html import escape
from django.utils.translation import gettext as _
from . import settings
from .models import options
from .models.models import BaseTagModel, TagModelQuerySet
from .utils import parse_tags, render_tags
class TagWidgetBase(forms.TextInput):
"""
Base class for tag widgets
"""
# Attributes that subclasses must set
autocomplete_settings = None
# Attributes that the calling Field must set
tag_options = None
autocomplete_tags = None
# Provide choices attribute for admin site, to avoid an error in the event
# tagulous.admin isn't used to register the admin model
choices = None
def render(self, name, value, attrs=None, renderer=None):
if attrs is None:
attrs = {}
# Try to provide a URL for the autocomplete to load tags on demand
autocomplete_view = self.tag_options.autocomplete_view
if autocomplete_view:
try:
attrs["data-tag-url"] = reverse(
autocomplete_view,
args=self.tag_options.autocomplete_view_args,
kwargs=self.tag_options.autocomplete_view_kwargs,
)
except NoReverseMatch as e:
raise ValueError("Invalid autocomplete view: %s" % e)
# Otherwise embed them, if provided
elif self.autocomplete_tags is not None:
autocomplete_tags = self.autocomplete_tags
# If it's a queryset, make sure it hasn't been consumed, otherwise
# changes won't show in the list
if isinstance(autocomplete_tags, QuerySet):
autocomplete_tags = autocomplete_tags.all()
attrs["data-tag-list"] = escape(
force_str(
json.dumps(
# Call str rather than tag.name directly, in case
# we've been given a list of tag strings
[str(tag) for tag in autocomplete_tags],
cls=DjangoJSONEncoder,
)
)
)
# Merge default autocomplete settings into tag options
tag_options = self.tag_options.form_items(with_defaults=False)
if self.default_autocomplete_settings is not None:
autocomplete_settings = self.default_autocomplete_settings.copy()
autocomplete_settings.update(tag_options.get("autocomplete_settings", {}))
tag_options["autocomplete_settings"] = autocomplete_settings
# Inject extra settings
tag_options.update({"required": self.is_required})
# Store tag options
attrs["data-tag-options"] = escape(
force_str(json.dumps(tag_options, cls=DjangoJSONEncoder))
)
# Mark it for the javascript to find
attrs["data-tagulous"] = "true"
# Turn off browser's autocomplete
attrs["autocomplete"] = "off"
# Render value
return super(TagWidgetBase, self).render(name, value, attrs)
class TagWidget(TagWidgetBase):
"""
Tag widget for public-facing forms
"""
default_autocomplete_settings = settings.AUTOCOMPLETE_SETTINGS
class Media:
css = settings.AUTOCOMPLETE_CSS
js = settings.AUTOCOMPLETE_JS
class AdminTagWidget(TagWidgetBase):
"""
Tag widget for admin forms
"""
default_autocomplete_settings = settings.ADMIN_AUTOCOMPLETE_SETTINGS
# Admin will be expecting this to have a choices attribute
# Set this so the admin will behave as expected
choices = None
@property
def media(self):
# Get the media from the AutocompleteMixin - this will give us Django's
# vendored jQuery and select2
media = AutocompleteMixin.media.fget(None)
return media + forms.Media(
js=settings.ADMIN_AUTOCOMPLETE_JS,
css=settings.ADMIN_AUTOCOMPLETE_CSS,
)
def render(self, name, value, attrs=None, renderer=None):
if attrs is None:
attrs = {}
attrs["data-theme"] = "admin-autocomplete"
return super().render(name, value, attrs, renderer)
class BaseTagField(forms.CharField):
"""
Base class for form tag fields
"""
# Use the tag widget
widget = TagWidget
def __init__(self, tag_options=None, autocomplete_tags=None, **kwargs):
"""
Takes all CharField options, plus:
tag_options A TagOptions instance
If not provided, uses Tagulous defaults
autocomplete_tags Iterable of tags to be used for autocomplete,
ie a queryset from a TagModel, or a list of
strings. Will be ignored if tag_options
contains autocomplete_view
"""
# Initialise as normal
super(BaseTagField, self).__init__(**kwargs)
# Add tag options and autocomplete tags
# Will use getters and setters to mirror onto widget
self.tag_options = tag_options or options.TagOptions()
self.autocomplete_tags = autocomplete_tags
def prepare_value(self, value):
"""
Prepare the value - a tag string
"""
# Catch no value (empty form for add)
if not value:
tag_string = ""
# Will normally get a string
elif isinstance(value, str):
tag_string = value
# Might be a QuerySet or list of tags, or a list of strings, passed as initial=
elif isinstance(value, TagModelQuerySet) or (
isinstance(value, (list, tuple))
and all(isinstance(part, (str, BaseTagModel)) for part in value)
):
tag_string = render_tags(value)
# Otherwise will be given by the model's TagField.value_from_object().
# The value comes from django.forms.model.model_to_dict, which thinks
# it produced a list of pks - but TagField.value_from_object tricked it
# by returning a list with a single item, the tag string.
else:
# Catch changes in model_to_dict which broke the trick
if len(value) != 1:
raise ValueError(_("Tag field could not prepare unexpected value"))
tag_string = value[0]
return super(BaseTagField, self).prepare_value(tag_string)
# Use setters and getters to ensure any changes to the field are mirrored
# in the widget, in the same way ModelChoiceField mirrors its queryset
def _get_tag_options(self):
return self._tag_options
def _prepare_tag_options(self, tag_options):
"Clone tag options"
return tag_options + options.TagOptions()
def _set_tag_options(self, tag_options):
tag_options = self._prepare_tag_options(tag_options)
self._tag_options = tag_options
self.widget.tag_options = tag_options
tag_options = property(_get_tag_options, _set_tag_options)
def _get_autocomplete_tags(self):
return self._autocomplete_tags
def _set_autocomplete_tags(self, autocomplete_tags):
self._autocomplete_tags = autocomplete_tags
self.widget.autocomplete_tags = autocomplete_tags
autocomplete_tags = property(_get_autocomplete_tags, _set_autocomplete_tags)
def widget_attrs(self, widget):
"""
Given a Widget instance (*not* a Widget class), returns a dictionary of
any HTML attributes that should be added to the Widget, based on this
Field.
"""
return {}
def to_python(self, value):
# Tags shouldn't be whitespace. Strip here for ``required`` validation
if isinstance(value, str):
value = value.strip()
return super(BaseTagField, self).to_python(value)
def clean(self, value, single=False):
"""
Clean the form value
If optional argument ``single`` is True, the returned value will be a
string containing the tag name.
If ``single`` is False (default), the returned value will be a list of
strings containing tag names.
"""
value = super(BaseTagField, self).clean(value)
if self.tag_options.force_lowercase:
value = value.lower()
if single:
return value
try:
return parse_tags(
value, self.tag_options.max_count, self.tag_options.space_delimiter
)
except ValueError as e:
raise forms.ValidationError(_("%s" % e))
class SingleTagField(BaseTagField):
"""
Single tag field
For parsing purposes, a single tag field wraps the contents in quotes
"""
def prepare_value(self, value):
"""
Prepare the value by stripping quotes
"""
# Might have been passed a Tag object via initial - convert to string
if isinstance(value, BaseTagModel):
value = value.name
tag_string = value
return super(SingleTagField, self).prepare_value(tag_string)
def _prepare_tag_options(self, tag_options):
"""
Force max_count to 1
"""
return tag_options + options.TagOptions(max_count=1)
def widget_attrs(self, widget):
"""
Given a Widget instance (*not* a Widget class), returns a dictionary of
any HTML attributes that should be added to the Widget, based on this
Field.
"""
attrs = super(SingleTagField, self).widget_attrs(widget)
attrs.update({"data-tag-type": "single"})
return attrs
def clean(self, value):
"""
Clean by parsing tag with quotes
"""
tag = super(SingleTagField, self).clean(value, single=True)
if tag:
return tag
else:
return None
class TagField(BaseTagField):
"""
Form tag field
"""
def prepare_value(self, value):
"""
Prepare the value
"""
# Could receive iterable of tags from a form's initial object
if isinstance(value, TagModelQuerySet) or (
hasattr(value, "__getitem__")
and all(isinstance(tag, BaseTagModel) for tag in value)
):
value = render_tags(value)
# Deal with it as normal
return super(TagField, self).prepare_value(value)
# ##############################################################################
# ###### Inline tagged formset
# ##############################################################################
class TaggedInlineFormSet(forms.models.BaseInlineFormSet):
"""
An inline formset base class which works when the model is a tagged model
using a SingleTagField, and the parent model is a tag model. Only affects
this usage, otherwise operates as a normal InlineFormSet.
When adding an inline instance, Django's BaseInlineFormSet sets the parent
model instance by fk id instead of fk value. This normally makes sense, but
it means Tagulous doesn't detect the change of tag, and can't update the
count. This formset updates the count after saving.
When editing an inline instance, Django's BaseInlineFormSet switches the
fk form field from SingleTagField to InlineForeignKeyField, which expects
the fk's pk - but when constructing the initial form data, it gets it from
the original field's value_from_object, in this case will be the tag name.
This formset corrects this back to use the fk's pk.
"""
def save(self, *args, **kwargs):
"""Saves and updates the tag count, if parent model is a tag model"""
obj = super(TaggedInlineFormSet, self).save(*args, **kwargs)
if isinstance(self.instance, BaseTagModel):
self.instance.update_count()
return obj
def _construct_form(self, i, **kwargs):
# Construct as normal
form = super(TaggedInlineFormSet, self)._construct_form(i, **kwargs)
# SingleTagField will have broken the pk - fix it by clearing and
# letting BoundField.value() use the field's initial value
if isinstance(self.instance, BaseTagModel) and self.fk.name in form.initial:
del form.initial[self.fk.name]
return form
django-tagulous-1.3.3/tagulous/management/ 0000775 0000000 0000000 00000000000 14161666113 0020605 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/tagulous/management/__init__.py 0000664 0000000 0000000 00000000000 14161666113 0022704 0 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/tagulous/management/commands/ 0000775 0000000 0000000 00000000000 14161666113 0022406 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/tagulous/management/commands/__init__.py 0000664 0000000 0000000 00000000000 14161666113 0024505 0 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/tagulous/management/commands/initial_tags.py 0000664 0000000 0000000 00000003715 14161666113 0025435 0 ustar 00root root 0000000 0000000 from django.apps import apps
from django.core.management.base import BaseCommand
from ...models.initial import field_initialise_tags, model_initialise_tags
class Command(BaseCommand):
"""
Load initial tagulous tags
Optional argument allows you to specify what to load
If field_name is missing, initialise all tag fields on the model
If model_name is missing, initialise all tag fields on models in the app
If app_name is missing, initialise all tag fields on all models in all apps
"""
help = "Load initial tagulous tags"
def add_arguments(self, parser):
parser.add_argument(
"--target",
type=str,
default="",
help="Target to load: [[.[.]]]",
)
def handle(self, target="", **options):
# Split up target argument
parts = target.split(".")
app_name, model_name, field_name = parts + ([None] * (3 - len(parts)))
# Look up app
if app_name:
app = apps.get_app_config(app_name)
else:
app = None
# Look up specific model, or get all models for the app
if model_name:
models = [app.get_model(model_name)]
elif app is None:
# Get all models for all apps
models = apps.get_models()
else:
models = app.get_models()
# If field is specified, can finish here
if field_name:
model = models[0]
field = model._meta.get_field(field_name)
loaded = field_initialise_tags(model, field, report=self.stdout)
if not loaded:
self.stdout.write(
"Nothing to load for %s.%s.%s\n"
% (model._meta.app_label, model.__name__, field.name)
)
return
# Step through all models and load
for model in models:
model_initialise_tags(model, report=self.stdout)
django-tagulous-1.3.3/tagulous/models/ 0000775 0000000 0000000 00000000000 14161666113 0017754 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/tagulous/models/__init__.py 0000664 0000000 0000000 00000001373 14161666113 0022071 0 ustar 00root root 0000000 0000000 """
Tagulous models
Make important functions and classes available on tagulous.models
"""
from ..signals.pre import register_pre_signals
from . import initial, migrations # noqa
from .descriptors import BaseTagDescriptor, SingleTagDescriptor, TagDescriptor # noqa
from .fields import ( # noqa
BaseTagField,
SingleTagField,
TagField,
singletagfields_from_model,
tagfields_from_model,
)
from .managers import SingleTagManager, TagRelatedManagerMixin # noqa
from .models import ( # noqa
BaseTagModel,
BaseTagTreeModel,
TagModel,
TagModelManager,
TagModelQuerySet,
TagTreeModel,
)
from .options import TagOptions # noqa
from .tagged import TaggedManager, TaggedModel, TaggedQuerySet # noqa
register_pre_signals()
django-tagulous-1.3.3/tagulous/models/cast.py 0000664 0000000 0000000 00000002514 14161666113 0021262 0 ustar 00root root 0000000 0000000 """
Manage instance casting
"""
import inspect
# Give all cast classes a name that's unique to Tagulous and not going to clash with any
# names in the originating class module
CAST_CLASS_PREFIX = "TagulousCastTagged"
def get_cast_class(orig_cls, new_base_cls):
"""
Get or create a class object that has the new base class and the original class as
base classes, eg
class NewClass(new_base_cls, orig_cls):
...
The class will be placed in the module of orig_cls
"""
# Determine name and module for cast class
orig_module = inspect.getmodule(orig_cls)
new_cls_name = f"{CAST_CLASS_PREFIX}{orig_cls.__name__}"
# See if we've already cast this class
if hasattr(orig_module, new_cls_name):
new_cls = getattr(orig_module, new_cls_name)
else:
# Make a subclass of TaggedQuerySet and the original class
new_cls = type(new_cls_name, (new_base_cls, orig_cls), {})
# Add to original module
new_cls.__module__ = orig_module.__name__
setattr(orig_module, new_cls_name, new_cls)
return new_cls
def cast_instance(instance, new_base_cls):
"""
Change the class of the object to use new_base_cls as a base class
"""
orig_cls = instance.__class__
new_cls = get_cast_class(orig_cls, new_base_cls)
instance.__class__ = new_cls
django-tagulous-1.3.3/tagulous/models/descriptors.py 0000664 0000000 0000000 00000017772 14161666113 0022705 0 ustar 00root root 0000000 0000000 """
Tagulous model field descriptors
When a model has a SingleTagField or TagField, they are replaced with these
descriptors during the ``contribute_to_class`` phase.
Their main purposes is to act as getter/setters and pass data to and from
manager instances.
"""
from collections.abc import Iterable
from django.db.models import Q
from .managers import FakeTagRelatedManager, SingleTagManager, TagRelatedManagerMixin
# ##############################################################################
# ###### Base class for tag field descriptors
# ##############################################################################
class BaseTagDescriptor(object):
"""
Base TagDescriptor class
"""
def __init__(self, descriptor):
# Store original FK/M2M descriptor and tag options
self.descriptor = descriptor
# Copy descriptor attributes
for key, val in descriptor.__dict__.items():
setattr(self, key, val)
# If the field was created using a string, the field's tag model and
# tag options will not be available when the descriptor is created, so
# cannot store them directly here
tag_model = property(lambda self: self.field.remote_field.model)
tag_options = property(lambda self: self.field.tag_options)
def load_initial(self):
"""
Load initial tags
Be prepared to receive a DatabaseError if the model has not been synced
"""
for tag_name in self.tag_options.initial:
self.tag_model.objects.get_or_create(
name=tag_name, defaults={"protected": self.tag_options.protect_initial}
)
def formfield(self, *args, **kwargs):
"""
Shortcut to access formfield
"""
return self.descriptor.field.formfield(*args, **kwargs)
# ##############################################################################
# ###### Descriptor for SingleTagField
# ##############################################################################
class SingleTagDescriptor(BaseTagDescriptor):
"""
Descriptor to set the tag string rather than a Tag object
Wraps the ReverseSingleRelatedObjectDescriptor and passes set and get
requests through to the SingleTagManager
"""
def __set__(self, instance, value):
# Check we've actually got an instance. No practical way this could
# happen, but Django does it, so we will too
if instance is None: # pragma: no cover
raise AttributeError("Manager must be accessed via instance")
# Otherwise set on the manager
manager = self.get_manager(instance)
manager.set(value)
def get_manager(self, instance, instance_type=None):
"""
Get the Manager instance for this field on this model instance.
Descriptor is instantiated once per class, so we bind the Manager to
the instance and collect it again when needed.
"""
# Get existing or create new SingleTagManager
attname = self.descriptor.field.get_manager_name()
manager = getattr(instance, attname, None)
if not manager:
manager = SingleTagManager(self, instance)
setattr(instance, attname, manager)
return manager
def __get__(self, instance, instance_type=None):
# If no instance, return self
if not instance:
return self
# Otherwise get from the manager
manager = self.get_manager(instance, instance_type)
related = manager.get()
if not related:
return related
# Add get_similar_objects()
field = self.field
def get_similar_objects():
# Start with all objects except the source object
qs = field.model.objects.exclude(pk=instance.pk)
# Find ones which match
qs = qs.filter(Q(**{f"{field.name}": getattr(instance, field.name)}))
return qs
related.get_similar_objects = get_similar_objects
return related
# ##############################################################################
# ###### Descriptor for TagField
# ##############################################################################
class TagDescriptor(BaseTagDescriptor):
"""
Descriptor to add tag functions to the RelatedManager
The ManyToManyField will create a ReverseManyRelatedObjectsDescriptor
This will use a RelatedManager which we cannot customise
This will intercept calls for the RelatedManager, and add the tag functions
"""
def get_manager(self, instance, instance_type=None):
"""
Get the Manager instance for this field on this model instance.
Descriptor is instantiated once per class, so we bind the Manager to
the instance and collect it again when needed.
While the instance is not saved (does not have a pk), a fake manager
is used to hold unsaved tags; database methods are disallowed.
"""
# Get existing mamager
attname = self.descriptor.field.get_manager_name()
manager = getattr(instance, attname, None)
manager_type = self.descriptor.related_manager_cls
# Find which manager we should be using
if instance.pk:
# Can use real manager
if isinstance(manager, FakeTagRelatedManager):
# Convert fake manager to real manager
fake_manager = manager
manager = self.create_manager(instance, instance_type)
manager.load_from_tagmanager(fake_manager)
elif manager is None:
# Create real manager
manager = self.create_manager(instance, instance_type)
# Otherwise already have real manager
else:
# Have to use the fake one
if isinstance(manager, manager_type):
# Was using a real manager, but instance must have been deleted
real_manager = manager
manager = FakeTagRelatedManager(self, instance, instance_type)
manager.load_from_tagmanager(real_manager)
elif manager is None:
# Create fake manager
manager = FakeTagRelatedManager(self, instance, instance_type)
# Otherwise already have a fake manager
# Set it in case it changed
setattr(instance, attname, manager)
return manager
def create_manager(self, instance, instance_type):
# Get the RelatedManager that should have been returned
manager = self.descriptor.__get__(instance, instance_type)
# Add in the mixin
manager.__class__ = type(
str("TagRelatedManager"), (TagRelatedManagerMixin, manager.__class__), {}
)
# Manager is already instantiated; initialise tagulous in it
manager.init_tagulous(self)
return manager
def __get__(self, instance, instance_type=None):
# If no instance, return self
if not instance:
return self
# Otherwise get from the manager
manager = self.get_manager(instance, instance_type)
return manager
def __set__(self, instance, value):
# Check we've actually got an instance. No practical way this could
# happen, but Django does it, so we will too
if instance is None: # pragma: no cover
raise AttributeError("Manager must be accessed via instance")
# Get the manager
manager = self.__get__(instance)
# Set value
if not value:
# Clear
manager.set_tag_string("")
elif isinstance(value, str):
# If it's a string, it must be a tag string
manager.set_tag_string(value)
elif isinstance(value, Iterable):
# An iterable goes in as a list of things that are, or can be
# converted to, strings
manager.set_tag_list(value)
else:
# Unknown
raise ValueError("Unexpected value assigned to TagField")
@property
def through(self):
return self.descriptor.through
django-tagulous-1.3.3/tagulous/models/fields.py 0000664 0000000 0000000 00000045653 14161666113 0021611 0 ustar 00root root 0000000 0000000 """
Tagulous model fields
These are the fields which users will add to models. During the
``contribute_to_class`` phase of model initialisation, they create any
necessary tag models, and add the descriptors back onto the model.
They are also responsible for preparing form fields.
"""
from django.core.checks import Warning as ChecksWarning
from django.db import models
from django.utils.text import capfirst
from .. import constants
from .descriptors import SingleTagDescriptor, TagDescriptor
from .models import BaseTagModel, TagModel, TagTreeModel
from .options import TagOptions
# ##############################################################################
# ###### Mixin for model tag fields
# ##############################################################################
class BaseTagField(object):
"""
Mixin for TagField and SingleTagField
"""
# List of fields which are forbidden from __init__
forbidden_fields = ()
def __init__(self, to=None, to_base=None, **kwargs):
"""
Initialise the tag options and store
Takes all tag options as keyword arguments, as long as there is no
``to`` tag model specified.
Undocumented keyword argument ``_set_tag_meta`` is used internally to
update tag model options with those specified in keyword arguments when
a ``to`` tag model is specified. However, this is intended for internal
use only (when migrating), so if you must use it, use it with care.
"""
# Save tag model data
self.tag_model = to
self.tag_model_base = to_base
# Extract options from kwargs
options = {}
for key, default in constants.OPTION_DEFAULTS.items():
# Look in kwargs, then in tag_meta
if key in kwargs:
options[key] = kwargs.pop(key)
# Detect if _set_tag_meta is set
set_tag_meta = kwargs.pop("_set_tag_meta", False)
# Detect whether we need to automatically generate a tag model
if self.tag_model:
self.auto_tag_model = False
# Tag model might be a string - set options later
self.tag_options = None
self._deferred_options = [set_tag_meta, options]
else:
self.auto_tag_model = True
self.tag_options = TagOptions(**options)
self._deferred_options = None
# If the tag model was not specified, we need to specify one.
# However, we can't reliably auto-generate a unique and repeatable
# model name for tags here in __init__ - we can only do that in
# contribute_to_class once we know the name of the field in the model.
# We'll therefore use the string '-'; Django will not do anything about
# resolving it until contribute_to_class, at which point we'll replace
# it with a reference to the real tag model.
kwargs["to"] = self.tag_model if self.tag_model else "-"
# Call super __init__
super(BaseTagField, self).__init__(**kwargs)
# Make a note that this has not been contributed to a class yet
self.contributed = False
def do_related_class(self, other, cls):
"""
Process tag model now it has been resolved if it was a string
"""
# Set up relation as normal
super(BaseTagField, self).do_related_class(other, cls)
# Make sure tag model is the related model, in case it was a string
self.tag_model = self.remote_field.model
# Check class type of tag model
if not issubclass(self.tag_model, BaseTagModel):
raise ValueError("Tag model must be a subclass of TagModel")
# Process the deferred options
self._process_deferred_options(is_to_self=self.tag_model == cls)
def _process_deferred_options(self, is_to_self=False):
"""
Process tag options once we have the related model
If the field is explicitly referring to itself, is_to_self will be True
"""
# See if tag options were deferred
if self._deferred_options is None:
return
# Get deferred options
set_tag_meta, options = self._deferred_options
self._deferred_options = None
# Set options
if options:
if set_tag_meta:
# Tag option arguments must be used to update the tag model
# (and any other tag fields which use it) - used during
# migration when the tag model doesn't know its own options
#
# However, to avoid issues with inheritance (particularly during
# migrations), clone the tag_options rather than changing in place
tag_options = self.tag_model.tag_options.clone()
self.tag_model.tag_options = tag_options.update(options)
else:
raise ValueError(
"Cannot set tag options on explicit tag model %r"
% (self.tag_model,)
)
# Link to model options by reference in case they get updated later
self.tag_options = self.tag_model.tag_options
def contribute_to_class(self, cls, name):
"""
Create the tag model if necessary, then initialise and contribute the
field to the class
"""
#
# Get or create the tag model
#
# Create a new tag model if we need to
if self.auto_tag_model:
# Generate a list of attributes for the new tag model
model_attrs = {
# Module should be the same as the main model
"__module__": cls.__module__,
# Give it access to the options
"tag_options": self.tag_options,
}
# Build new tag model
# Name is Tagulous_MODELNAME_FIELDNAME
model_name = "%s_%s_%s" % (
constants.MODEL_PREFIX,
cls._meta.object_name,
name,
)
if self.tag_model_base is not None:
model_cls = self.tag_model_base
elif self.tag_options.tree:
model_cls = TagTreeModel
else:
model_cls = TagModel
self.tag_model = type(model_name, (model_cls,), model_attrs)
# Give it a verbose name, for admin filters
verbose_name_singular = (
self.tag_options.verbose_name_singular or self.verbose_name or name
)
verbose_name_plural = self.tag_options.verbose_name_plural
if not verbose_name_plural:
verbose_name_plural = verbose_name_singular or self.verbose_name or name
if not verbose_name_plural.endswith("s"):
verbose_name_plural += "s"
# Get object verbose name
object_name = cls._meta.verbose_name
self.tag_model._meta.verbose_name = "%s %s" % (
object_name,
verbose_name_singular,
)
self.tag_model._meta.verbose_name_plural = "%s %s" % (
object_name,
verbose_name_plural,
)
# Make no attempt to enforce max length of verbose_name - no good
# automatic solution, and the limit may change, see
# https://code.djangoproject.com/ticket/17763
# If it's a problem, contrib.auth will raise a ValidationError
#
# Build the tag field
#
# Update the rel on the field
self.remote_field.model = self.tag_model
# Contribute to class
super(BaseTagField, self).contribute_to_class(cls, name)
self.contributed = True
def formfield(self, form_class, **kwargs):
"""
Common actions for TagField and SingleTagField to set up a formfield
"""
required = not self.blank
if hasattr(self, "required"):
required = self.required
# Update tag options, if necessary
tag_options = self.tag_options
if "tag_options" in kwargs:
new_options = kwargs.pop("tag_options")
if not isinstance(new_options, TagOptions):
new_options = TagOptions(**new_options)
tag_options += new_options
# Start off with defaults
options = {
# Arguments the TagField base (CharField) would expect
"label": capfirst(self.verbose_name),
"help_text": self.help_text,
"required": required,
# Also pass tag options
"tag_options": tag_options,
}
# Update with kwargs
options.update(kwargs)
# Add in list of tags for autocomplete, if appropriate
if "autocomplete_tags" in kwargs:
options["autocomplete_tags"] = kwargs["autocomplete_tags"]
elif not tag_options.autocomplete_view:
tags = self.tag_model.objects.all()
if tag_options.autocomplete_initial:
tags = tags.initial()
options["autocomplete_tags"] = tags
# Create the field instance
return form_class(**options)
def get_manager_name(self):
"""
Get the field name for the Manager
"""
return constants.TAGGED_ATTR_MANAGER % self.name
def deconstruct(self):
"""
Deconstruct field options to a dict for __init__
"""
name, path, args, kwargs = super(BaseTagField, self).deconstruct()
# Find tag model options
if isinstance(self.tag_options, TagOptions):
# When deconstruct is called on a real field on a real model,
# we will have a concrete tag model, so use its tag options
items = self.tag_options.items(with_defaults=False)
# Freeze initial as a string, not array
if "initial" in items:
items["initial"] = self.tag_options.initial_string
elif self._deferred_options is not None:
# When deconstruct is called on a ModelState field, the options
# will have been deferred
set_tag_meta, options = self._deferred_options
items = options
else: # pragma: no cover
# It should never get here - raise an exception so we can debug
raise ValueError("Unexpected state")
# Add tag model options to kwargs
kwargs.update(items)
# Can't freeze lambdas. It should work if it's a function at the top
# level of a module, but there's no easy way to differentiate. For
# safety and consistency, strip callable arguments and mention in
# documentation.
if "get_absolute_url" in kwargs:
del kwargs["get_absolute_url"]
# Remove forbidden fields
# This shouldn't be needed, but strip them just in case
for forbidden in self.forbidden_fields: # pragma: no cover
if forbidden in kwargs:
del kwargs[forbidden]
# Always store _set_tag_meta=True, so migrating tag fields can set tag
# models' TagMeta
kwargs["_set_tag_meta"] = True
return name, path, args, kwargs
# ##############################################################################
# ###### Single tag field
# ##############################################################################
class SingleTagField(BaseTagField, models.ForeignKey):
"""
Build the tag model and register the TagForeignKey
Not actually a field - syntactic sugar for creating tag fields
"""
description = "A single tag field"
# List of fields which are forbidden from __init__
forbidden_fields = ("to_field", "rel_class", "max_count")
def __init__(self, *args, **kwargs):
"""
Create a single tag field - a tag field which can only take one tag
See docs/models.rst for a list of arguments
"""
# Forbid certain ForeignKey arguments
for forbidden in self.forbidden_fields:
if forbidden in kwargs:
raise ValueError("Invalid argument '%s' for SingleTagField" % forbidden)
# TagFields will need to be nulled in the database when deleting,
# regardless of whether we want to allow them to be null or not.
# Make a note of whether this is required.
self.required = not kwargs.pop("blank", False)
kwargs["blank"] = True
kwargs["null"] = True
# Set default on_delete
if "on_delete" not in kwargs:
kwargs["on_delete"] = models.CASCADE
# Create the tag field
super(SingleTagField, self).__init__(*args, **kwargs)
def contribute_to_class(self, cls, name):
"""
Create the related tag model, initialise the ForeignKey with it,
and set up the model to use the SingleTagDescriptor instead of the
ReverseSingleRelatedObjectDescriptor
"""
# Standard BaseTagField contribute
super(SingleTagField, self).contribute_to_class(cls, name)
# Replace the descriptor with our own
old_descriptor = getattr(cls, name)
new_descriptor = SingleTagDescriptor(old_descriptor)
setattr(cls, name, new_descriptor)
def value_from_object(self, obj):
"""
Returns the value of the foreign key as a tag string, for a form
"""
tag = getattr(obj, self.name)
if tag:
return tag.name
return ""
def formfield(self, form_class=None, **kwargs):
"""
Create the form field
For arguments see forms.TagField
"""
if form_class is None:
from ..forms import SingleTagField as FormSingleTagField
form_class = FormSingleTagField
return super(SingleTagField, self).formfield(form_class=form_class, **kwargs)
# ##############################################################################
# ###### Tag field
# ##############################################################################
class TagField(BaseTagField, models.ManyToManyField):
"""
Build the tag model and register the TagManyToManyField
Not actually a field - syntactic sugar for creating tag fields
Will not allow a through table
"""
description = "A tag field"
# List of fields which are forbidden from __init__
forbidden_fields = ("db_table", "through", "symmetrical")
def __init__(self, *args, **kwargs):
"""
Create a Tag field
See docs/models.rst for a list of arguments
"""
# Forbid certain ManyToManyField arguments
for forbidden in self.forbidden_fields:
if forbidden in kwargs:
raise ValueError("Invalid argument '%s' for TagField" % forbidden)
# Note things we'll need to restore after __init__
help_text = kwargs.pop("help_text", "")
null = kwargs.pop("null", False)
super(TagField, self).__init__(*args, **kwargs)
# Change default help text
self.help_text = help_text or "Enter a comma-separated tag string"
self.null = null
def _check_ignored_options(self, **kwargs):
warnings = []
if getattr(self, "null", False):
warnings.append(
ChecksWarning(
"null has no effect on TagField.",
hint=None,
obj=self,
id="fields.W340",
)
)
self.has_null_arg = False
self.null = None
return warnings + super(TagField, self)._check_ignored_options(**kwargs)
def contribute_to_class(self, cls, name):
"""
Create the related tag model, initialise the ManyToManyField with it,
and set up the model to use the TagDescriptor
"""
# Standard BaseTagField contribute
super(TagField, self).contribute_to_class(cls, name)
# Replace the descriptor with our own
old_descriptor = getattr(cls, name)
new_descriptor = TagDescriptor(old_descriptor)
setattr(cls, name, new_descriptor)
def value_from_object(self, obj):
"""
Tricks django.forms.models.model_to_dict into passing data to the form.
Because the models.TagField is based on a django ManyToManyField,
model_to_dict expects a queryset, which it changes to a list of pks
for use in a ModelMultipleChoiceField.
Instead, we want to pass the tag string to a forms.TagField, which is a
subclass of CharField. We can't do this in the TagField itself because
there's no model context by that stage to do the pk lookup.
We therefore return a fake queryset containing a single fake item,
where the pk attribute is the tag string - a bit of a hack, but avoids
monkey-patching Django.
"""
class FakeObject(object):
"""
FakeObject so m2d can check obj.pk
"""
def __init__(self, value):
self.pk = value
def __str__(self):
return self.pk
class FakeQuerySet(object):
"""
FakeQuerySet so m2d can call qs.values_list()
Only contains one FakeObject instance
"""
def __init__(self, obj):
self.obj = obj
self._result_cache = None
def __iter__(self):
"""
Iterable so m2d can use in list comprehension
"""
yield self.obj
def __len__(self):
return 1
def __getitem__(self, key):
return self.obj
def values_list(self, *fields, **kwargs):
"""
Ignores arguments and returns an empty list with the object.pk
"""
return [self.obj.pk]
return FakeQuerySet(FakeObject(getattr(obj, self.attname).get_tag_string()))
def formfield(self, form_class=None, **kwargs):
"""
Create the form field
For arguments see forms.TagField
"""
if form_class is None:
from ..forms import TagField as FormTagField
form_class = FormTagField
return super(TagField, self).formfield(form_class=form_class, **kwargs)
def save_form_data(self, instance, data):
"""
When the form wants to save this data, it will only be doing so after
the instance has been saved. This must be committed to the database.
"""
setattr(instance, self.attname, data)
getattr(instance, self.attname).save()
# ##############################################################################
# ###### Field util methods
# ##############################################################################
def singletagfields_from_model(model):
"""
Get a list of SingleTagField fields from a model class
"""
return [field for field in model._meta.fields if isinstance(field, SingleTagField)]
def tagfields_from_model(model):
"""Get a list of TagField fields from a model class"""
return [field for field in model._meta.many_to_many if isinstance(field, TagField)]
django-tagulous-1.3.3/tagulous/models/initial.py 0000664 0000000 0000000 00000002710 14161666113 0021757 0 ustar 00root root 0000000 0000000 from .fields import SingleTagField, TagField
#
# Functions to load initial tags
# Used by tests and the management command `initialtags`
#
def field_initialise_tags(model, field, report=None):
"""
Load any initial tags for the specified tag field
You will not normally need to call this directly - instead use the
management command ``initialtags``.
Arguments:
model Model containing the field
field Field with initial tags to load
report Optional: a file handle to write verbose reports to
Returns True if loaded, False if nothing to load
"""
if not field.tag_options.initial:
return False
if report:
report.write(
"Loading initial tags for %s.%s.%s\n"
% (model._meta.app_label, model.__name__, field.name)
)
descriptor = getattr(model, field.name)
descriptor.load_initial()
return True
def model_initialise_tags(model, report=None):
"""
Load any initial tags for the given model
You will not normally need to call this directly - instead use the
management command ``initialtags``.
Arguments:
model Model to check for tag fields to load
report Optional: a file handle to write verbose reports to
"""
fields = model._meta.get_fields()
for field in fields:
if isinstance(field, (SingleTagField, TagField)):
field_initialise_tags(model, field, report)
django-tagulous-1.3.3/tagulous/models/managers.py 0000664 0000000 0000000 00000052645 14161666113 0022137 0 ustar 00root root 0000000 0000000 """
Tagulous model field managers
These are accessed via the descriptors, and do the work of storing and loading
the tags.
For tag model manager, look in tagulous.models.models
"""
from django.core import exceptions
from ..utils import parse_tags, render_tags
# ##############################################################################
# ###### Manager for SingleTagField
# ##############################################################################
class SingleTagManager(object):
"""
Manage single tags
Not a real Django manager; it's a per-instance abstraction between the
normal FK descriptor to hold in-memory changes of the SingleTagField before
passing them up to the normal FK descriptor on the pre-save signal.
"""
def __init__(self, descriptor, instance):
# The SingleTagDescriptor and instance this manages
self.descriptor = descriptor
self.instance = instance
# Other vars we need
self.tag_model = self.descriptor.tag_model
self.field = self.descriptor.field
self.tag_options = self.descriptor.tag_options
# Keep track of unsaved changes
self.changed = False
# The descriptor stores an unsaved tag string
# Load the actual value into the cache, if it exists
# If there is a problem with the actual value, get_actual will fall
# back to our cache, so make sure it exists first
self.tag_cache = None
self.tag_cache = self.get_actual()
# Start off the local tag name with the actual tag name
self.tag_name = self.tag_cache.name if self.tag_cache else None
# Pre/post save will need to keep track of an old tag
self.removed_tag = None
def flush_cache(self):
"""
Clear the FK descriptor's cache
Must be called after all
"""
if self.field.is_cached(self.instance):
self.field.delete_cached_value(self.instance)
def get_actual(self):
"""
Get the actual value of the instance according to the FK descriptor
"""
# A ForeignKey would be on the .attname (field_id), but only
# if it has been set, otherwise the attribute will not exist.
#
# In Django <1.9 we could just check for the attribute, but 1.10
# sets a DeferredAttribute on the field id to load it on demand, so
# we need to check the dict directly instead
check_value = self.field.attname in self.instance.__dict__
# Check the value if we need to
if check_value:
try:
value = self.descriptor.descriptor.__get__(self.instance)
except (self.tag_model.DoesNotExist, self.instance.DoesNotExist):
# Django 1.10 returns instance.DoesNotExist, so check for both.
#
# If the tag is deleted but nobody tells this instance; because
# the real cache is kept empty, this will fail. Try our cache,
# and if it's set clear the pk.
self.changed = True
if self.tag_cache:
self.tag_cache.pk = None
return self.tag_cache
# The descriptor will have populated the cache, but Django 1.8
# introduces a check of the cache before allowing save() to start.
# We can't guarantee that the tag object will have a pk until the
# pre-save handler has fired - which happens after the cache check.
# We therefore have to keep the cache clean at all times - we don't
# lose anything since we keep our own cache, and pre-save will fill
# it out in time anyway.
self.flush_cache()
return value
return None
def set_actual(self, value):
"""
Set the actual value of the instance for the FK descriptor
"""
self.descriptor.descriptor.__set__(self.instance, value)
# Django 1.8 cache check fix (see comment in get_actual)
self.flush_cache()
def get(self):
"""
Get the current tag - either a Tag object or None
If the field has been changed since the instance was last saved, the
Tag object may be a dynamically generated Tag which does not exist in
the database yet. The count will not be updated until the instance is
next saved.
"""
# If changed, find the tag
if self.changed:
if not self.tag_name:
return None
# Try to look up the tag
try:
if self.tag_options.case_sensitive:
tag = self.tag_model.objects.get(name=self.tag_name)
else:
tag = self.tag_model.objects.get(name__iexact=self.tag_name)
except self.tag_model.DoesNotExist:
# Does not exist yet, create a temporary one (but don't save)
if not self.tag_cache:
self.tag_cache = self.tag_model(name=self.tag_name, protected=False)
tag = self.tag_cache
return tag
else:
# Return the response that it should have had (a Tag or None)
return self.get_actual()
def set(self, value):
"""
Set the current tag
"""
if not value:
tag_name = ""
elif isinstance(value, str):
# Force tag to lowercase
if self.tag_options.force_lowercase:
value = value.lower()
tag_name = value
# Look up the tag name
else:
tag_name = value.name
# If no change, do nothing
if self.tag_name == tag_name:
return
# Store the tag name and mark changed
self.changed = True
self.tag_name = tag_name
self.tag_cache = None
def pre_save_handler(self):
"""
When the model is about to save, update the tag value
"""
# Get the new tag
new_tag = self.get()
# Logic check to replace standard null/blank model field validation
if not new_tag and self.field.required:
raise exceptions.ValidationError(self.field.error_messages["null"])
# Only need to go further if there has been a change
if not self.changed:
return
# Store the old tag so we know to decrement it in post_save
self.removed_tag = self.get_actual()
# Create or increment the tag object
if new_tag:
# Ensure it is in the database
if not new_tag.pk:
new_tag.save()
# Increment the new tag
new_tag.increment()
# Set it
self.set_actual(new_tag)
# Clear up
self.changed = False
def post_save_handler(self):
"""
When the model has saved, decrement the old tag
"""
if self.removed_tag:
self.removed_tag.decrement()
def post_delete_handler(self):
"""
When the model has been deleted, decrement the actual tag
"""
# Decrement the actual tag
old_tag = self.get_actual()
if not old_tag:
return
# Try to update the old tag
try:
old_tag.decrement()
except type(old_tag).DoesNotExist:
# The tag was just deleted along with the model in the same operation - most
# likely a cascade delete originated on the tag model
pass
# Clear the tag on this instance so we don't leave a reference
self.set_actual(None)
# If there is no new value, mark the old one as a new one,
# so the database will be updated if the instance is saved again
if not self.changed:
self.tag_name = old_tag.name
self.tag_cache = None
self.changed = True
# ##############################################################################
# ###### Mixin for TagField manager
# ##############################################################################
class BaseTagRelatedManager(object):
"""
Mixin for TagRelatedManagerMixin, and base class for FakeTagRelatedManager.
Provides methods to managed cached tags
"""
@property
def tags(self):
if not hasattr(self, "_tags") or self._tags is None:
try:
self._tags = list(self.all())
except AttributeError:
self._tags = []
return self._tags
@tags.setter
def tags(self, value):
self._tags = value
def init_tagulous(self, descriptor):
"""
Called directly after the mixin is added to the instantiated manager
"""
self.tag_model = descriptor.tag_model
self.tag_options = descriptor.tag_options
# Maintain an internal set of tags, and track whether they've changed
# If internal tags are None, haven't been loaded yet
self.changed = False
self.tags = None
def __str__(self):
"""
If called on an instance, return the tag string
"""
return self.get_tag_string()
def __contains__(self, item):
item_str = str(item)
if self.tag_options.force_lowercase:
item_str = item_str.lower()
if self.tag_options.case_sensitive:
return item_str in [tag.name for tag in self.tags]
return item_str in [tag.name.lower() for tag in self.tags]
def __eq__(self, other):
"""
Compare a tag string or iterable of tags to the tags on this manager
"""
# If not case sensitive, or lowercase forced, compare on lowercase
lower = False
if self.tag_options.force_lowercase or not self.tag_options.case_sensitive:
lower = True
# Prep other argument we're comparing against
if isinstance(other, BaseTagRelatedManager):
other = other.tags
if isinstance(other, str):
other_str = str(other)
# Enforce case non-sensitivity or lowercase
if lower:
other_str = other_str.lower()
# Parse other_str into list of tags
other_tags = parse_tags(
other_str, space_delimiter=self.tag_options.space_delimiter
)
else:
# Assume it's an iterable
other_tags = other
if lower:
other_tags = [str(tag).lower() for tag in other]
# Get list of set tags
self_tags = self.get_tag_list()
# Compare tag count
if len(other_tags) != len(self_tags):
return False
# Compare tags
for tag in self_tags:
# If lowercase or not case sensitive, lower for comparison
if lower:
tag = tag.lower()
# Check tag in other tags
if tag not in other_tags:
return False
# Same number of tags, and all self tags present in other tags
# It's a match
return True
def __ne__(self, other):
"""
Compare tags, using opposite of __eq__
"""
return not self.__eq__(other)
def load_from_tagmanager(self, manager):
"""
Copy status and cache from the specified manager
"""
self.changed = manager.changed
self.tags = manager.tags
#
# Functions for getting and setting tag cache
#
def get_tag_string(self):
"""
Get the tag edit string for this instance as a string
"""
return render_tags(self.tags)
def get_tag_list(self):
"""
Get the tag names for this instance as a list of tag names
"""
return [tag.name for tag in self.tags]
def set_tag_string(self, tag_string):
"""
Sets the tags for this instance, given a tag edit string
"""
# Get all tag names
tag_names = parse_tags(
tag_string, space_delimiter=self.tag_options.space_delimiter
)
# Pass on to set_tag_list
return self.set_tag_list(tag_names)
set_tag_string.alters_data = True
def set_tag_list(self, tag_names):
"""
Sets the tags for this instance, given a list of tag names, or a list
or queryset of tags
"""
if self.tag_options.max_count and len(tag_names) > self.tag_options.max_count:
raise ValueError(
"Cannot set more than %d tags on this field"
% self.tag_options.max_count
)
# Force tag_names to strings, in case it's a list of tags or a queryset
tag_names = [str(tag_name) for tag_name in tag_names]
# Apply force_lowercase
if self.tag_options.force_lowercase:
# Will be lowercase for later comparison
tag_names = [name.lower() for name in tag_names]
# Prep tag lookup
# old_tags = { cmp_name: tag }
# cmp_new_names = { cmp_name: cased_name }
if self.tag_options.case_sensitive:
old_tags = dict([(tag.name, tag) for tag in self.tags])
cmp_new_names = dict([(n, n) for n in tag_names])
else:
# Not case sensitive - need to compare on lowercase
old_tags = dict([(tag.name.lower(), tag) for tag in self.tags])
cmp_new_names = dict([(name.lower(), name) for name in tag_names])
# See which tags are staying
new_tags = []
for cmp_old_name, old_tag in old_tags.items():
if cmp_old_name in cmp_new_names:
# Exists - add to new tags
new_tags.append(old_tag)
del cmp_new_names[cmp_old_name]
else:
# Tag will be removed
self.changed = True
# Only left with tag names which aren't present
for tag_name in cmp_new_names.values():
# Find or create all new tags
try:
if self.tag_options.case_sensitive:
tag = self.tag_model.objects.get(name=tag_name)
else:
tag = self.tag_model.objects.get(name__iexact=tag_name)
except self.tag_model.DoesNotExist:
# Don't create it until it's saved
tag = self.tag_model(name=tag_name, protected=False)
# Add the tag
new_tags.append(tag)
self.changed = True
# Store in internal tag cache
self.tags = new_tags
set_tag_list.alters_data = True
class FakeTagRelatedManager(BaseTagRelatedManager):
"""
Fake manager class to manage cached tags, but provide no database access.
For use with an unsaved model instance
"""
_needs_db = '"%r" needs to be saved before TagField can use the database'
def __init__(self, descriptor, instance, instance_type):
self.instance = instance
self.model = instance.__class__
self.init_tagulous(descriptor)
def reload(self):
"""
Instance does not exist in the database, so should wipe the tags
"""
self.tags = []
self.changed = False
def save(self, force=False):
raise ValueError(self._needs_db % self.instance)
def set(self, *args):
raise ValueError(self._needs_db % self.instance)
def add(self, *args):
raise ValueError(self._needs_db % self.instance)
def remove(self, *args):
raise ValueError(self._needs_db % self.instance)
def clear(self):
raise ValueError(self._needs_db % self.instance)
class TagRelatedManagerMixin(BaseTagRelatedManager):
"""
Mixin for RelatedManager to add tag functions
Added to the normal m2m RelatedManager, after it has been instantiated.
This holds in-memory changes of the TagField before committing them to the
database on the post-save signal.
"""
def reload(self):
"""
Get the actual tags
"""
# Convert to a list to force it to load now, and so we can change it
self.tags = list(self.all())
self.changed = False
reload.alters_data = True
def post_save_handler(self):
"""
When the model has saved, save related tags
Called by the signal handler
"""
self.save()
def pre_delete_handler(self):
"""
Safely clear the M2M tag field, persisting tags on the manager
When deleting an instance, Django does not call the add/remove of the
M2M manager, so tag counts would be too high. Related to:
https://code.djangoproject.com/ticket/6707
We need to clear the M2M manually to update tag counts
Called by the signal handler
"""
# Get tags so we can make them available to the fake manager later
self.reload()
tags = self.tags
# Clear the object
self.clear()
# Put the tags back on the manager
self.tags = tags
def save(self, force=False):
"""
Set the actual tags to the internal tag state
If force is True, save whether we think it has changed or not
"""
if not self.changed and not force:
return
# Add and remove tags as necessary
new_tags = self._ensure_tags_in_db(self.tags)
self.reload()
# Add new tags
for new_tag in new_tags:
if new_tag not in self.tags:
self.add(new_tag, _enforce_max_count=False)
# Remove old tags
for old_tag in self.tags:
if old_tag not in new_tags:
self.remove(old_tag)
self.tags = new_tags
self.changed = False
save.alters_data = True
def _ensure_tags_in_db(self, tags):
"""
Ensure that self.tags all exist in the database
"""
db_tags = []
for tag in tags:
if tag.pk:
# Already in DB
db_tag = tag
else:
# Not in DB - get or create
field_lookup = "name"
if not self.tag_options.case_sensitive:
field_lookup += "__iexact"
db_tag, __ = self.tag_model.objects.get_or_create(
defaults={"name": tag.name, "protected": False},
**{field_lookup: tag.name},
)
db_tags.append(db_tag)
return db_tags
#
# New set, add, remove and clear, to update tag counts
#
def set(self, objs, **kwargs):
self.clear()
self.add(*objs)
def add(self, *objs, **kwargs):
"""
Add a list of tags or tag strings
Takes on internal argument, _enforce_max_count - don't use in your code
"""
enforce_max_count = kwargs.pop("_enforce_max_count", True)
if kwargs:
raise TypeError("add() got an unexpected keyword argument")
# Convert strings to tag objects
new_tags = []
for tag in objs:
if isinstance(tag, str):
new_tags.append(self.tag_model(name=tag))
else:
new_tags.append(tag)
# Don't trust the internal tag cache
self.reload()
# Reduce tags to ones not already loaded
new_tags = [tag for tag in new_tags if tag not in self.tags]
# Enforce max_count
if enforce_max_count and self.tag_options.max_count:
current_count = len(self.tags)
if current_count + len(new_tags) > self.tag_options.max_count:
raise ValueError(
"Cannot set more than %s tags on this field; it already has %s"
% (self.tag_options.max_count, current_count)
)
# Ensure tags exist
new_tags = self._ensure_tags_in_db(new_tags)
# Add to db, add to cache, and increment
super(TagRelatedManagerMixin, self).add(*new_tags)
for tag in new_tags:
self.tags.append(tag)
tag.increment()
add.alters_data = True
def remove(self, *objs):
# Convert strings to tag objects - if object doesn't exist, skip
rm_tags = []
for tag in objs:
if isinstance(tag, str):
try:
rm_tags.append(self.tag_model.objects.get(name=tag))
except self.tag_model.DoesNotExist:
continue
else:
rm_tags.append(tag)
# Don't trust the internal tag cache
self.reload()
# Cut tags back to only ones already set
rm_tags = [tag for tag in self.tags if tag in rm_tags]
# Remove from cache
self.tags = [tag for tag in self.tags if tag not in rm_tags]
# Remove from db and decrement
super(TagRelatedManagerMixin, self).remove(*self._ensure_tags_in_db(rm_tags))
for tag in rm_tags:
tag.decrement()
remove.alters_data = True
def clear(self):
# Don't trust the internal tag cache
self.reload()
# Clear db, then decrement and empty cache
super(TagRelatedManagerMixin, self).clear()
for tag in self.tags:
tag.decrement()
self.tags = []
clear.alters_data = True
def get_similar_objects(self):
"""
Find similarly tagged objects
Example::
related_objects_qs = myobject.tags.get_similar_objects()
is equivalent to::
related_objects_qs = MyModel.objects.similarly_tagged(myobject, 'tags')
"""
tagged_model = self.source_field.related_model
similar = tagged_model.objects.similarly_tagged(
self.instance, field_name=self.prefetch_cache_name
)
return similar
django-tagulous-1.3.3/tagulous/models/migrations.py 0000664 0000000 0000000 00000012663 14161666113 0022512 0 ustar 00root root 0000000 0000000 """
Migration support for Django migrations
"""
from django.db import migrations
from .models import BaseTagModel, BaseTagTreeModel
# ##############################################################################
# ########################################################### Django migrations
# ##############################################################################
def django_support():
# Monkey-patch Django so it doesn't flatten TagModel abstract base classes.
# We need them so the BaseTagModel metaclass can set up its options, and
# so that tag model functionality is available in migrations.
old_from_model = migrations.state.ModelState.from_model.__func__
def from_model(cls, model, exclude_rels=False):
base = None
if issubclass(model, BaseTagTreeModel):
base = BaseTagTreeModel
elif issubclass(model, BaseTagModel):
base = BaseTagModel
modelstate = old_from_model(cls, model, exclude_rels)
if base is not None:
modelstate.bases = (base,) + modelstate.bases
return modelstate
migrations.state.ModelState.from_model = classmethod(from_model)
# Add Tagulous support to Django migrations
django_support()
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Helpers for Django migrations
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
class ChangeModelBases(migrations.operations.base.Operation):
"""
Change a Model's bases so it is correct for data migrations
"""
def __init__(self, name, bases):
self.name = name
self.bases = bases
def state_forwards(self, app_label, state):
state.models[app_label, self.name.lower()].bases = self.bases
def database_forwards(self, *args, **kwargs):
pass
def database_backwards(self, *args, **kwargs):
pass
def add_unique_field(model_name, name, field, preserve_default, set_fn):
"""
Helper for Django migrations which returns a list of Operations to add a
unique field.
Warning: only use on a database which supports transactions, in case your
set_fn method fails and leaves your database in an unusable state.
Create a migration and provide the string 'x' as the default when prompted.
Then find the field definition in your migration and replace it with a call
to this function, removing the default:
operations = [
migrations.AddField(
...
),
migrations.AddField(
model_name='mymodel',
name='my_column',
field=models.TextField(default='x', unique=True),
preserve_default=False,
),
migrations.AddField(
...
),
]
becomes:
def set_new_column(obj):
obj.new_column = slugify(obj.name)
operations = [
migrations.AddField(
...
),
] + tagulous.models.migration.add_unique_field(
model_name='mymodel',
name='my_column',
field=models.TextField(unique=True),
preserve_default=False,
set_fn=set_new_column,
) + [
migrations.AddField(
...
),
]
Arguments:
model_name As django defines
name As django defines
field As django defines, but without default
preserve_default As django defines
set_fn Callback to set the field on each instance
"""
if migrations is None: # pragma: no cover
raise ValueError("Cannot use add_unique_column without Django migrations")
# Clone the field so it's not unique and can be null
field_nullable = field.clone()
field_nullable._unique = False
field_nullable.null = True
# RunPython doesn't give the code the app label; pass it as an attribute
# to save users having to specify the app
class RunPythonWithAppLabel(migrations.RunPython):
def database_forwards(self, app_label, *args, **kwargs):
self.code.app_label = app_label
super(RunPythonWithAppLabel, self).database_forwards(
app_label, *args, **kwargs
)
def database_backwards(self, app_label, *args, **kwargs):
self.code.app_label = app_label
super(RunPythonWithAppLabel, self).database_backwards(
app_label, *args, **kwargs
)
# Function to generate the unique value
def set_unique_values(apps, schema_editor):
model = apps.get_model(set_unique_values.app_label, model_name)
# Make sure tag models won't mess with data during this operation
is_tag_model = issubclass(model, BaseTagModel)
for obj in model.objects.all():
set_fn(obj)
if is_tag_model:
obj._save_direct()
else: # pragma: no cover - no need, _save_direct() calls save()
obj.save()
return [
migrations.AddField(
model_name=model_name,
name=name,
field=field_nullable,
preserve_default=preserve_default,
),
RunPythonWithAppLabel(set_unique_values, reverse_code=lambda *a, **k: None),
migrations.AlterField(
model_name=model_name,
name=name,
field=field,
preserve_default=preserve_default,
),
]
django-tagulous-1.3.3/tagulous/models/models.py 0000664 0000000 0000000 00000064404 14161666113 0021621 0 ustar 00root root 0000000 0000000 """
Tagulous tag models
"""
from django.db import IntegrityError, models, router, transaction
from django.db.models import F, Max
from django.db.models.functions import Floor
from django.utils.text import slugify
from .. import constants, settings, utils
from .options import TagOptions
# ##############################################################################
# ###### TagModel manager and queryset
# ##############################################################################
class TagModelQuerySet(models.query.QuerySet):
def initial(self):
"""
Reduce the queryset to only include initial tags left in the queryset
"""
return self.filter(name__in=self.model.tag_options.initial)
def filter_or_initial(self, *args, **kwargs):
"""
Reduce the queryset to match the specified filter, but also include
any initial tags left in the queryset.
An example of usage would be where tags are only visible to the user
who added them, but you also want them to see the initial default tags.
"""
return self.filter(
models.Q(*args, **kwargs)
| models.Q(name__in=self.model.tag_options.initial)
)
def weight(self, min=settings.WEIGHT_MIN, max=settings.WEIGHT_MAX):
"""
Add a ``weight`` integer field to objects, weighting the ``count``
between ``min`` and ``max``.
Suitable for use with a tag cloud
"""
# Ignoring PEP 8 intentionally regarding conflict of min/max keywords -
# concerns are outweighed by clarity of function argument names.
# Weight is the count scaled to the min/max bounds
# weight = ( (count * (max - min)) / max_count ) + min
scale = int(max) - int(min)
max_count = self.model.objects.aggregate(Max("count"))["count__max"] or 1
qs = self.annotate(weight=(Floor(F("count") * scale) / max_count) + int(min))
return qs
def __str__(self):
return utils.render_tags(self)
class BaseTagModelManager(models.Manager):
def __str__(self):
return str(self.get_queryset())
TagModelManager = BaseTagModelManager.from_queryset(TagModelQuerySet)
# ##############################################################################
# ###### Abstract base class for all TagModel models
# ##############################################################################
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Metaclass for tag models
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
class TagModelBase(models.base.ModelBase):
def __new__(cls, name, bases, attrs):
# Set up as normal
new_cls = super(TagModelBase, cls).__new__(cls, name, bases, attrs)
# TagMeta takes priority for the model
new_tag_options = None
if "TagMeta" in attrs:
tag_meta = {}
tag_meta = dict(
(key, val)
for key, val in attrs["TagMeta"].__dict__.items()
if key in constants.OPTION_DEFAULTS
)
if "tree" in tag_meta:
raise ValueError("Cannot set tree option in TagMeta")
new_tag_options = TagOptions(**tag_meta)
# Failing that, look for a direct tag_options setting
# It will probably have been passed by BaseTagField.contribute_to_class
elif "tag_options" in attrs:
new_tag_options = attrs["tag_options"]
# Otherwise start a new one
else:
new_tag_options = TagOptions()
# See if there's anything to inherit
# This also means that tag_options will be available on abstract models
if hasattr(new_cls, "tag_options"):
# Inherit by setting missing values in place
new_tag_options.set_missing(new_cls.tag_options)
# Assign
new_cls.tag_options = new_tag_options
# Check for self-referential tag fields on this model
fields = new_cls._meta.fields + new_cls._meta.many_to_many
for field in fields:
# Can't test for subclass of field here - would be circular import
if hasattr(field, "tag_model") and field.tag_model == new_cls:
# This method is being called after the tag field's
# contribute_to_class and _process_deferred_options. This means
# that the field is using tag_options from the inherited model.
# Change it to use this one
field.tag_options = new_tag_options
return new_cls
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Empty abstract model
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
class BaseTagModel(models.Model, metaclass=TagModelBase):
"""
Empty abstract base class for tag models
This is used when dynamically building models, eg in migrations
"""
objects = TagModelManager()
class Meta:
abstract = True
def __str__(self):
return str(self.name)
def __eq__(self, obj):
"""
If comparing to a string, is equal if string value matches
Otherwise compares normally
"""
if isinstance(obj, str):
return self.name == obj
return super(BaseTagModel, self).__eq__(obj)
__hash__ = models.Model.__hash__
def __ne__(self, obj):
return not self == obj
def get_absolute_url(self):
if self.tag_options.get_absolute_url is None:
raise AttributeError(
"'%s' has no attribute 'get_absolute_url'" % self.__class__.__name__
)
return self.tag_options.get_absolute_url(self)
@classmethod
def get_related_fields(cls, include_standard=False):
"""
Return a list of related tag fields in other models which refer to this
tag model.
If include_standard=False (default), only SingleTagFields and
TagFields will be returned. If True, it will also include ForeignKeys
and ManyToManyFields.
"""
# Avoid circular import
from .fields import SingleTagField, TagField
meta = cls._meta
related_fields = [
f
for f in meta.get_fields()
if (f.many_to_many or f.one_to_many or f.one_to_one) and f.auto_created
]
if include_standard:
return related_fields
return [
f
for f in related_fields
if isinstance(
f.field,
(
SingleTagField,
TagField,
),
)
]
def get_related_objects(self, flat=False, distinct=False, include_standard=False):
"""
Get any instances of other models which refer to this tag instance
If flat=False, returns the following data structure:
[
[related_model, related_field, [instance, instance, ...],
[related_model, related_field, [instance, instance, ...],
...
]
If flat=False, the distinct argument is ignored. Models and fields
will only be included if they refer to this specific tag - there will
not be any empty lists of instances.
If flat=True, returns a list of instances without any information about
how they are related:
[ instance, instance, ... ]
If flat=True and distinct=True, only unique instances will be returned.
If include_standard=False (default), only SingleTagFields and
TagFields will be returned. If True, it will also include ForeignKeys
and ManyToManyFields.
"""
data = []
for related in self.get_related_fields(include_standard=include_standard):
related_model = related.related_model
objs = related_model._base_manager.using(
router.db_for_write(self.tag_model)
).filter(**{"%s" % related.field.name: self})
if not objs:
continue
if flat:
data.extend(objs)
else:
data.append([related_model, related.field, objs])
if flat and distinct:
data = list(set(data))
return data
def update_count(self):
"""
Count how many SingleTagFields and TagFields refer to this tag, save,
and try to delete.
"""
self.count = len(self.get_related_objects(flat=True))
self.save()
self.try_delete()
update_count.alters_data = True
def increment(self):
"""
Increase the count by one
"""
self._change_count(1)
increment.alters_data = True
def decrement(self):
"""
Decrease the count by one, then try to delete
"""
self._change_count(-1)
decrement.alters_data = True
def _change_count(self, amount):
"""
Change count by amount
"""
self.__class__.objects.filter(pk=self.pk).update(
count=models.F("count") + amount
)
# Reload count
# Use DB for write because we just updated the value
using = router.db_for_write(self.tag_model, instance=self)
self.refresh_from_db(using=using)
self.try_delete()
def try_delete(self):
"""
If count is 0, try to delete this tag
"""
if self.count != 0:
return
# See if it's protected
is_protected = self.protected or self.tag_options.protect_all
if not is_protected:
# Before we delete, check for any standard relationships
# This will catch if the tag is in a tree with children
true_count = len(self.get_related_objects(flat=True, include_standard=True))
if true_count > 0:
# ForeignKeys or ManyToManyFields refer to it
# We can't delete (we'll break things)
# Tag is protected, for now
is_protected = True
# Try to delete
if not is_protected:
# Tag is not in use and not protected. Delete.
self.delete()
# If a tree, parent node may now be empty - try to delete it
if self.tag_options.tree and self.parent:
self.parent.try_delete()
try_delete.alters_data = True
def _prep_merge_tags(self, tags):
"""
Ensure tags argument for merge_tags is an iterable of tag objects,
excluding self
"""
# Ensure tags is a list of tag instances
if isinstance(tags, str):
tags = utils.parse_tags(
tags, space_delimiter=self.tag_options.space_delimiter
)
if not isinstance(tags, models.query.QuerySet):
tags = self.tag_model.objects.filter(name__in=tags)
# Make sure self isn't in tags
return tags.exclude(pk=self.pk)
def merge_tags(self, tags):
"""
Merge the specified tags into this tag
"""
# Avoid circular import
from .fields import SingleTagField, TagField
related_fields = self.tag_model.get_related_fields()
tags = self._prep_merge_tags(tags)
for related in related_fields:
# Get the instances of the related models which refer to the tag
# instances being merged
related_model = related.related_model
objs = related_model._base_manager.using(
router.db_for_write(self.tag_model, instance=self)
).filter(**{"%s__in" % related.field.name: tags})
# Switch the tags
if isinstance(related.field, SingleTagField):
for obj in objs:
setattr(obj, related.field.name, self)
obj.save()
elif isinstance(related.field, TagField):
for obj in objs:
getattr(obj, related.field.name).remove(*tags)
getattr(obj, related.field.name).add(self)
merge_tags.alters_data = True
def _update_extra(self):
"""
Called by .save() before super().save()
Allows subclasses to update extra fields based on slug
"""
pass
def _save_direct(self, *args, **kwargs):
"""
Save without modifying data
Used during schemamigrations
"""
# We inherited from BaseTagModel, tell that to save directly too
return super(BaseTagModel, self).save(*args, **kwargs)
def save(self, *args, **kwargs):
"""
Automatically generate a unique slug, if one does not exist
"""
# Based on django-taggit: don't worry about race conditions when
# setting names and slugs, just avoid potential slugify clashes.
# We could improve this if race conditions are ever a problem in the
# real world, but until Django provides a reliable way to determine
# the cause of an IntegrityError, we can never make this perfect.
# If already in the database and has a slug set, just save as normal
# Set slug to None to rebuild it
if self.pk and self.slug:
self._update_extra()
return super(BaseTagModel, self).save(*args, **kwargs)
# Set the slug using the label if possible (for TagTreeModel), else
# the tag name.
label = getattr(self, "label", self.name)
slug_max_length = self.__class__._meta.get_field("slug").max_length
if settings.SLUG_ALLOW_UNICODE:
slug_base = slugify(label, allow_unicode=True)
else:
slug_base = slugify(label, allow_unicode=False)
# Django 3.2 strips trailing and leading underscores; this risks creating an
# empty slug for unconvertable characters, eg logographic characters. Ensure
# they are not empty.
if slug_base == "":
slug_base = "_"
# ASCII-ification can make a longer string
self.slug = slug_base[:slug_max_length]
self._update_extra()
# Make sure we're using the same db at all times
cls = self.__class__
kwargs["using"] = kwargs.get("using") or router.db_for_write(cls, instance=self)
# Try saving the slug - it'll probably be fine
try:
# If transaction supports atomic, we need to wrap the save call -
# otherwise if save throws an exception it'll cause any current
# queries to roll back
with transaction.atomic():
return super(BaseTagModel, self).save(*args, **kwargs)
except IntegrityError:
pass
# Integrity error - something is probably not unique.
# Assume it was the slug - make it unique by appending a number.
# See which numbers have been used
slug_base = slug_base[: slug_max_length - settings.SLUG_TRUNCATE_UNIQUE]
based_objects = cls.objects.filter(slug__regex="^%s_[0-9]+$" % slug_base)
based_slugs = list(based_objects.values_list("slug", flat=True))
if len(based_slugs) == 0:
# No numbered version of the slug exists
number = 1
else:
numbers = [int(slug.rsplit("_", 1)[1]) for slug in based_slugs]
number = sorted(numbers)[-1] + 1
self.slug = "%s_%d" % (slug_base, number)
self._update_extra()
return super(BaseTagModel, self).save(*args, **kwargs)
save.alters_data = True
# For consistency with SingleTagField, provide .tag_model attribute
tag_model = property(lambda self: self.__class__)
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Abstract model with fields
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
class TagModel(BaseTagModel):
"""
Abstract base class for tag models
"""
name = models.CharField(unique=True, max_length=settings.NAME_MAX_LENGTH)
slug = models.SlugField(unique=False, max_length=settings.SLUG_MAX_LENGTH)
count = models.IntegerField(
default=0, help_text="Internal counter of how many times this tag is in use"
)
protected = models.BooleanField(
default=False, help_text="Will not be deleted when the count reaches 0"
)
class Meta:
abstract = True
ordering = ("name",)
# Slug field must be unique, but manage it with unique_together
# so that subclasses can override
unique_together = (("slug",),)
# ##############################################################################
# ###### TagTreeModel manager and queryset
# ##############################################################################
class TagTreeModelQuerySet(TagModelQuerySet):
def _clean(self):
"""
Return a clean copy of this class
"""
kwargs = {"model": self.model, "using": self._db}
if hasattr(self, "_hints"):
kwargs["hints"] = self._hints
return self.__class__(**kwargs)
def with_ancestors(self):
"""
Add selected tags' ancestors to current queryset
"""
# Build list of all paths of all ancestors (and self)
paths = []
for path in self.values_list("path", flat=True):
parts = utils.split_tree_name(path)
paths += [path] + [
utils.join_tree_name(parts[:i]) # Join parts up to i (misses last)
for i in range(1, len(parts)) # Skip first (empty)
]
return self._clean().filter(path__in=set(paths))
def with_descendants(self):
"""
Add selected tags' descendants to current queryset
"""
# Build query of all matching paths, and all their sub-paths
query = models.Q()
for path in self.values_list("path", flat=True):
query = (
query | models.Q(path=path) | models.Q(path__startswith="%s/" % path)
)
return self._clean().filter(query)
def with_siblings(self):
"""
Add selected tags' siblings to current queryset
"""
# Get all unique parent pks, except None
parent_ids = set(self.values_list("parent_id", flat=True))
has_none = None in parent_ids
if has_none:
parent_ids.remove(None)
# If None is there, we need to test with isnull
query = models.Q(parent_id__in=list(parent_ids))
if has_none:
query = query | models.Q(parent_id__isnull=True)
return self._clean().filter(query)
class TagTreeModelManager(TagModelManager):
def get_queryset(self):
return TagTreeModelQuerySet(self.model, using=self._db)
get_query_set = get_queryset
def rebuild(self):
"""
Re-save each instance to update tag fields
"""
for tag in self.all():
# Replace slug in case name has changed
# If it hasn't, it'll just end up re-creating the same one
tag.slug = None
tag.save()
rebuild.alters_data = True
# ##############################################################################
# ###### Abstract base class for all TagTreeModel models
# ##############################################################################
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Metaclass for tag tree models
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
class TagTreeModelBase(TagModelBase):
def __new__(cls, name, bases, attrs):
# Set up as normal
new_cls = super(TagTreeModelBase, cls).__new__(cls, name, bases, attrs)
# Force tree tag_options to True
new_cls.tag_options.tree = True
return new_cls
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Empty abstract model
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
class BaseTagTreeModel(BaseTagModel, metaclass=TagTreeModelBase):
"""
Empty abstract base class for tag models with tree
This is used when dynamically building models, eg in migrations
"""
objects = TagTreeModelManager()
class Meta:
abstract = True
# Other derivable attributes won't be used in lookups, so don't need to be
# cached. If there are situations where they are needed for lookups, this
# model can be subclassed (or better yet, use a reusable mixin) and the
# properties replaced by caching fields.
def _get_descendant_count(self):
"The sum of the counts of all descendants"
return self.get_descendants().aggregate(models.Sum("count"))["count__sum"] or 0
descendant_count = property(
_get_descendant_count, doc=_get_descendant_count.__doc__
)
def _get_family_count(self):
"The count of self plus all its descendants"
return self.descendant_count + self.count
family_count = property(_get_family_count, doc=_get_family_count.__doc__)
def __init__(self, *args, **kwargs):
"""
Initialise the tag
"""
super(BaseTagTreeModel, self).__init__(*args, **kwargs)
# Keep track of the name
self._name = self.name
def _save_direct(self, *args, **kwargs):
"""
Save without modifying data
Used during schemamigrations
"""
# We inherited from BaseTagModel, tell that to save directly too
return super(BaseTagTreeModel, self)._save_direct(*args, **kwargs)
def save(self, *args, **kwargs):
"""
Set the parent and path cache
"""
# Make sure name is valid
if self.name is None or not self.name.strip():
raise IntegrityError(
"NOT NULL constraint failed: {}.name".format(self._meta.db_table)
)
self.name = utils.clean_tree_name(self.name)
# Find the parent, or create it if missing
parts = utils.split_tree_name(self.name)
old_parent = self.parent
if len(parts) > 1:
self.parent, created = self.__class__.objects.get_or_create(
name=utils.join_tree_name(parts[:-1])
)
else:
self.parent = None
# Update other cache fields
self.label = parts[-1]
self.level = len(parts)
# Save - super .save() method will set the path using _get_path()
super(BaseTagTreeModel, self).save(*args, **kwargs)
# If name has changed...
if self._name != self.name:
# Update child names
for child in self.children.all():
child.name = utils.join_tree_name(parts + [child.label])
child.save()
self._name = self.name
# Notify parent that it may now be empty
if old_parent:
old_parent.update_count()
save.alters_data = True
def _update_extra(self):
"""
Updates extra fields based on slug
"""
# Update the path
if self.parent:
self.path = "/".join([self.parent.path, self.slug])
else:
self.path = self.slug
_update_extra.alters_data = True
def merge_tags(self, tags, children=False):
"""
Merge the specified tags into this tag
If children is True, child tags will also be merged into children of
this tag (retaining structure)
"""
tags = self._prep_merge_tags(tags)
# Merge children first
if children:
cls = self.__class__
for tag in tags:
for child in tag.children.all():
# Find merge target on this tree
new_child_name = "/".join([self.name, child.label])
try:
my_child = cls.objects.get(name=new_child_name)
except cls.DoesNotExist:
my_child = None
if my_child:
# It exists - merge recursively
my_child.merge_tags([child], children=True)
else:
# It doesn't exist - rename recursively
child.name = new_child_name
child.save()
# Merge self
super(BaseTagTreeModel, self).merge_tags(tags)
merge_tags.alters_data = True
def get_ancestors(self):
"""
Get a queryset of ancestors for this tree node
"""
cls = self.__class__
if not self.parent:
return cls.objects.none()
# Get all ancestor paths from this path
parts = utils.split_tree_name(self.path)
paths = [
utils.join_tree_name(parts[:i]) # Join parts up to i (misses last)
for i in range(1, len(parts)) # Skip first (empty)
]
# Look up ancestors by path, already ordered by name for deepest last
return cls.objects.filter(path__in=paths)
def get_descendants(self):
"""
Get a queryset of descendants of this tree node
"""
# Look up by path, already ordered by name for deepest last
cls = self.__class__
return cls.objects.filter(path__startswith="%s/" % self.path)
def get_siblings(self):
"""
Get a queryset of siblings of this tree node, including this node.
If you don't want this node in the results, exclude it afterwards, eg:
node.get_siblings().exclude(pk=node.pk)
"""
if self.parent:
return self.parent.children.all()
return self.__class__.objects.filter(level=1)
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Abstract model with fields
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
class TagTreeModel(BaseTagTreeModel, TagModel):
"""
Abstract base class for tag models with tree
"""
# These fields are all generated automatically on save
parent = models.ForeignKey(
"self",
null=True,
blank=True,
related_name="children",
on_delete=models.CASCADE,
db_index=True,
)
path = models.TextField()
label = models.CharField(
max_length=settings.LABEL_MAX_LENGTH,
help_text="The name of the tag, without ancestors",
)
level = models.IntegerField(default=1, help_text="The level of the tag in the tree")
class Meta:
abstract = True
ordering = ("name",)
unique_together = (("slug", "parent"),)
django-tagulous-1.3.3/tagulous/models/options.py 0000664 0000000 0000000 00000010737 14161666113 0022031 0 ustar 00root root 0000000 0000000 """
Tag options
"""
from .. import constants
from ..utils import parse_tags, render_tags
class TagOptions(object):
"""
Simple class container for tag options
"""
def __init__(self, **kwargs):
"""
Set up tag options using defaults, overridden by keyword arguments
"""
self.update(kwargs)
def update(self, options):
"""
Update this TagOptions in place with options from a dict or TagOptions
"""
# Ensure a dict
if isinstance(options, TagOptions):
options = options.items(with_defaults=False)
for key, val in options.items():
setattr(self, key, val)
return self
def set_missing(self, options):
"""
Update this TagOptions in place with options from a dict or TagOptions,
but only where the keys are not already set on this TagOptions
Similar to opt1 = opt2 + op1, only changes in place
"""
# Ensure a dict
if isinstance(options, TagOptions):
options = options.items(with_defaults=False)
# Get currently set keys
items = self.items(with_defaults=False)
for key, val in options.items():
if key not in items:
setattr(self, key, val)
return self
def contribute_to_class(self, cls, name):
"""
Add to class
"""
setattr(cls, name, self)
def __setattr__(self, name, value):
"""
Only allow an option to be set if it's valid
"""
if name == "initial":
# Store as a list of strings, with the tag string available on
# initial_string for migrations
if value is None:
self.__dict__["initial_string"] = ""
self.__dict__["initial"] = []
elif isinstance(value, str):
self.__dict__["initial_string"] = value
self.__dict__["initial"] = parse_tags(value)
else:
self.__dict__["initial_string"] = render_tags(value)
self.__dict__["initial"] = value
elif name in constants.OPTION_DEFAULTS:
self.__dict__[name] = value
else:
raise AttributeError(name)
def __getattr__(self, name):
"""
Fall back to default options if it's not set
Requests for locally-defined properties will be fielded directly by
__dict__
"""
if name == "initial_string":
# If here, there is no initial set in the __dict__
# There is nothing in defaults to fall back to either
return ""
if name not in constants.OPTION_DEFAULTS:
raise AttributeError(name)
return self.__dict__.get(name, constants.OPTION_DEFAULTS[name])
def _get_items(self, with_defaults, keys):
"""
Return a dict of options specified in keys, with defaults if required
"""
if with_defaults:
return dict(
[
(name, self.__dict__.get(name, constants.OPTION_DEFAULTS[name]))
for name in keys
]
)
return dict(
[(name, value) for name, value in self.__dict__.items() if name in keys]
)
def items(self, with_defaults=True):
"""
Get a dict of all options
If with_defaults is True, any missing options will be set to their
defaults; if False, missing options will be omitted.
"""
return self._get_items(with_defaults, constants.OPTION_DEFAULTS)
def form_items(self, with_defaults=True):
"""
Get a dict of all options in FORM_OPTIONS, suitable for rendering
into the data-tag-options attribute of the field HTML.
If with_defaults is True, any missing options will be set to their
defaults; if False, missing options will be omitted.
"""
return self._get_items(with_defaults, constants.FORM_OPTIONS)
def clone(self):
"""
Return a new TagOptions object with the options set on this object.
"""
dct = self.items(with_defaults=False)
return TagOptions(**dct)
def __add__(self, options):
"""
Return a new TagOptions object with the options set on this object,
overridden by any on the second specified TagOptions object.
"""
dct = self.items(with_defaults=False)
dct.update(options.items(with_defaults=False))
return TagOptions(**dct)
django-tagulous-1.3.3/tagulous/models/tagged.py 0000664 0000000 0000000 00000042066 14161666113 0021571 0 ustar 00root root 0000000 0000000 """
Tagulous extensions for models which use tag fields (tagged models)
These are all applied automatically when the TAGULOUS_ENHANCE_MODELS setting
is enabled.
"""
import copy
import django
from django.core.exceptions import FieldDoesNotExist
from django.db import models, transaction
from .. import utils
from ..constants import TAGGED_ATTR_MANAGER
from .cast import cast_instance
from .fields import (
BaseTagField,
SingleTagField,
TagField,
singletagfields_from_model,
tagfields_from_model,
)
def _split_kwargs(model, kwargs, lookups=False, with_fields=False):
"""
Split kwargs into fields which are safe to pass to create, and
m2m tag fields, creating SingleTagFields as required.
If lookups is True, TagFields with tagulous-specific lookups will also be
matched, and the returned tag_fields will be a dict of tuples in the
format ``(val, lookup)``
The only tagulous-specific lookup is __exact
For internal use only - likely to change significantly in future versions
Returns a tuple of safe_fields, singletag_fields, tag_fields
If with_fields is True, a fourth argument will be returned - a dict to
look up Field objects from their names
"""
safe_fields = {}
singletag_fields = {}
tag_fields = {}
field_lookup = {}
for field_name, val in kwargs.items():
# Check for lookup
if lookups and "__" in field_name:
orig_field_name = field_name
field_name, lookup = field_name.split("__", 1)
# Only one known lookup
if lookup == "exact":
try:
field = model._meta.get_field(field_name)
except FieldDoesNotExist:
# Unknown - pass it on untouched
pass
else:
if isinstance(field, TagField):
# Store for later
tag_fields[field_name] = (val, lookup)
field_lookup[field_name] = field
continue
# Irrelevant lookup - no need to take special actions
safe_fields[orig_field_name] = val
continue
# No lookup
# Try to look up the field
try:
field = model._meta.get_field(field_name)
except FieldDoesNotExist:
# Assume it's something clever and pass it through untouched
# If it's invalid, an error will be raised later anyway
safe_fields[field_name] = val
# Next field
continue
field_lookup[field_name] = field
# Take special measures depending on field type
if isinstance(field, SingleTagField):
singletag_fields[field_name] = val
elif isinstance(field, TagField):
# Store for later
if lookups:
tag_fields[field_name] = (val, None)
else:
tag_fields[field_name] = val
else:
safe_fields[field_name] = val
if with_fields:
return safe_fields, singletag_fields, tag_fields, field_lookup
return safe_fields, singletag_fields, tag_fields
# ##############################################################################
# ############################################################## TaggedQuerySet
# ##############################################################################
class TaggedQuerySet(models.query.QuerySet):
"""
A QuerySet with support for Tagulous tag fields
"""
def _filter_or_exclude(self, negate, *args, **kwargs):
"""
Custom lookups for tag fields
"""
if django.VERSION >= (3, 2):
# Arguments changed to _filter_or_exclude(self, negate, args, kwargs)
if len(args) == 2:
args, kwargs = args
elif set(kwargs.keys()) == {"args", "kwargs"}:
args, kwargs = kwargs["args"], kwargs["kwargs"]
# TODO: Replace with custom lookups
safe_fields, singletag_fields, tag_fields, field_lookup = _split_kwargs(
self.model, kwargs, lookups=True, with_fields=True
)
# Look up string values for SingleTagFields by name
for field_name, val in singletag_fields.items():
query_field_name = field_name
if isinstance(val, str):
query_field_name += "__name"
if not field_lookup[field_name].tag_options.case_sensitive:
query_field_name += "__iexact"
safe_fields[query_field_name] = val
# Query as normal
if django.VERSION >= (3, 2):
qs = super(TaggedQuerySet, self)._filter_or_exclude(
negate, args, safe_fields
)
else:
qs = super(TaggedQuerySet, self)._filter_or_exclude(
negate, *args, **safe_fields
)
# Look up TagFields by string name
#
# Each of these comparisons will be done with a subquery; for
# A filter can chain, ie .filter(tags__name=..).filter(tags__name=..),
# but exclude won't work that way; has to be done with a subquery
for field_name, val in tag_fields.items():
val, lookup = val
tag_options = field_lookup[field_name].tag_options
# Only perform custom lookup if value is a string
if not isinstance(val, str):
if django.VERSION >= (3, 2):
qs = super(TaggedQuerySet, self)._filter_or_exclude(
negate, [], {field_name: val}
)
else:
qs = super(TaggedQuerySet, self)._filter_or_exclude(
negate, **{field_name: val}
)
continue
# Parse the tag string
tags = utils.parse_tags(val, space_delimiter=tag_options.space_delimiter)
# Prep the subquery
subqs = qs
if negate:
subqs = self.__class__(model=self.model, using=self._db)
# To get an exact match, filter this queryset to only include
# items with a tag count that matches the number of specified tags
if lookup == "exact":
count_name = "_tagulous_count_%s" % field_name
subqs = subqs.annotate(**{count_name: models.Count(field_name)}).filter(
**{count_name: len(tags)}
)
# Explicit order as meta ordering will be ignored
subqs = subqs.order_by("name")
# Prep the field name
query_field_name = field_name + "__name"
if not tag_options.case_sensitive:
query_field_name += "__iexact"
# Now chain the filters for each tag
#
# Have to do it this way to create new inner joins for each tag;
# ANDing Q objects will do it all on a single inner join, which
# will match nothing
for tag in tags:
subqs = subqs.filter(**{query_field_name: tag})
# Fold subquery back into main query
if negate:
# Exclude on matched ID
qs = qs.exclude(pk__in=subqs.values("pk"))
else:
# A filter op can just replace the main query
qs = subqs
return qs
def create(self, **kwargs):
# Create object as normal
safe_fields, singletag_fields, tag_fields = _split_kwargs(self.model, kwargs)
# Could convert SingleTagFields to instances with
# field.tag_model.objects.get_or_create, but model constructor will
# assign it through the descriptor anyway, so this is unnecessary.
# SingleTagFields are safe
safe_fields.update(singletag_fields)
with transaction.atomic():
# Create as normal
obj = super(TaggedQuerySet, self).create(**safe_fields)
# Add tag fields
for field_name, val in tag_fields.items():
setattr(obj, field_name, val)
getattr(obj, field_name).save()
return obj
def get_or_create(self, defaults=None, **kwargs):
# Get or create object as normal
safe_fields, singletag_fields, tag_fields = _split_kwargs(self.model, kwargs)
# As in .create, SingleTagFields are ok to create
# Existing .get will be fine for lookup
safe_fields.update(singletag_fields)
# Use normal get_or_create if there are no tag fields
if len(tag_fields) == 0:
return super(TaggedQuerySet, self).get_or_create(defaults, **safe_fields)
# Try to find it using get - that is able to handle tag_fields
try:
return self.get(**kwargs), False
except self.model.DoesNotExist:
return self.create(**kwargs), True
@classmethod
def cast_class(cls, queryset):
"""
Changes the class of the specified queryset to a subclass of TaggedQuerySet
and the original class, so it has all the same properties it did when it
was first initialised, but is now a TaggedQuerySet subclass.
The new class is given the same name as the old class, but with the prefix
CAST_CLASS_PREFIX to indicate the type of the object has changed, eg a normal
QuerySet will become TagulousCastTaggedQuerySet.
"""
cast_instance(queryset, cls)
return queryset
def similarly_tagged(self, instance, field_name):
"""
Filter the queryset to objects which are similarly tagged to the specified model
instance.
Arguments:
instance Instance of the model whose tags we're comparing to
field_name Name of TagField where we're checking similarity
"""
# Start with a queryset of the tagged model, excluding the instance
qs = self.exclude(pk=instance.pk)
# Annotate with count of similarly tagged
q_filter = {f"{field_name}__in": getattr(instance, field_name).all()}
similar = qs.annotate(
tagulous_similarity=models.Count(
field_name,
models.Q(**q_filter),
distinct=True,
)
)
# Exclude any zero matches
similar = similar.exclude(tagulous_similarity=0)
# Order by similarity with most similar first
ordering = ["-tagulous_similarity"] + list(similar.model._meta.ordering)
similar = similar.order_by(*ordering)
return similar
# ##############################################################################
# ############################################################## TaggedManager
# ##############################################################################
class TaggedManager(models.Manager):
"""
A manager with support for Tagulous tag fields
"""
# The class of a tag-enabled queryset. Here so a custom TaggedManager can
# replace it with a custom TaggedQuerySet subclass.
tagulous_queryset = TaggedQuerySet
def _enhance_queryset(self, qs):
"""
Enhance an existing queryset with the class in self.tagulous_queryset
"""
return self.tagulous_queryset.cast_class(qs)
def get_queryset(self, *args, **kwargs):
"""
Get the original queryset and then enhance it
"""
qs = super(TaggedManager, self).get_queryset(*args, **kwargs)
return self._enhance_queryset(qs)
@classmethod
def cast_class(cls, manager):
"""
Changes the class of the specified manager to a subclass of TaggedManager
and the original class, so it has all the same properties it did when it
was first initialised, but is now a TaggedManager subclass.
The new class is given the same name as the old class, but with the prefix
CAST_CLASS_PREFIX to indicate the type of the object has changed, eg a normal
Manager will become TagulousCastTaggedManager
"""
cast_instance(manager, cls)
return manager
def similarly_tagged(self, instance, field_name):
return self.get_queryset().similarly_tagged(instance, field_name)
# ##############################################################################
# ############################################################## TaggedModel
# ##############################################################################
class TaggedModel(models.Model):
"""
An abstract model base class with support for Tagulous tag fields
"""
def __init__(self, *args, **kwargs):
safe_fields, singletag_fields, tag_fields = _split_kwargs(self, kwargs)
# Constructor has always been happy with ForeignKeys
safe_fields.update(singletag_fields)
# Call old init
super(TaggedModel, self).__init__(*args, **safe_fields)
# Add on TagField values
for field_name, val in tag_fields.items():
setattr(self, field_name, val)
def __getstate__(self):
"""
Pickle tag fields
"""
state = super().__getstate__()
for field in self._meta.get_fields():
if isinstance(field, BaseTagField):
# Remove manager from state
attr = TAGGED_ATTR_MANAGER % field.name
if attr in state:
del state[attr]
return state
@classmethod
def cast_class(cls, model):
"""
If the model contains tag fields, change the model to subclass
TaggedModel and enhance its managers. Called automatically on all
models with tag fields when settings.ENHANCE_MODELS is True.
Arguments:
model The model to turn into a TaggedModel subclass.
Will only be changed if it has tag fields.
"""
# See if there are tag fields on this model
tag_fields = singletagfields_from_model(model) + tagfields_from_model(model)
# If there are no tag fields skip
if not tag_fields:
return
# Ensure the model subclasses TaggedModel
if not issubclass(model, TaggedModel):
model.__bases__ = (TaggedModel,) + model.__bases__
# Ensure the manager subclasses TaggedManager
if hasattr(model, "objects") and not issubclass(
model.objects.__class__, TaggedManager
):
TaggedManager.cast_class(model.objects)
return model
@classmethod
def _detag_to_serializable(cls):
"""
Clone a fake version of this model, replacing tag fields with Field
objects, because their to_python method will not modify arguments.
Used by serializers to pass list values for tag fields through the
python serializer, to be loaded back into the real tagged model when
safe.
"""
# Get fields on this model
fields = cls._meta.get_fields()
# Create a fake model
class FakeTaggedModel(models.Model):
def __init__(self, *args, **kwargs):
# Django 3.2 introduced a TypeError when trying to instantiate an
# abstract model. Set it to False to get past the check.
if django.VERSION >= (3, 2):
self._meta.abstract = False
super().__init__(*args, **kwargs)
if django.VERSION >= (3, 2):
self._meta.abstract = True
def _retag_to_original(self):
"""
Convert this instance into an instance of the proper class it
should have been, before _detag_to_serializable converted it.
"""
# cls and fields from closure's scope
data = {}
for field in fields:
# ManyToOneRel and ManyToManyRel objects have no attribute
# contribute_to_class
if isinstance(field, (models.ManyToOneRel, models.ManyToManyRel)):
continue
# Find fields which are either TagFields, or not M2Ms -
# anything which Deserializer will have stored data for
elif isinstance(field, TagField) or not (
field.remote_field
and isinstance(field.remote_field, models.ManyToManyRel)
):
# Get data from object
data[field.name] = getattr(self, field.name)
return cls(**data)
class Meta:
abstract = True
# Add fields to fake model
for field in fields:
if isinstance(field, (models.ManyToOneRel, models.ManyToManyRel)):
# ManyToOneRel and ManyToManyRel objects have no attribute
# contribute_to_class
continue
elif isinstance(field, BaseTagField):
clone_field = models.Field(blank=field.blank, null=field.null)
else:
clone_field = copy.deepcopy(field)
clone_field.contribute_to_class(FakeTaggedModel, field.name)
FakeTaggedModel._tagulous_original_cls = cls
return FakeTaggedModel
class Meta:
abstract = True
django-tagulous-1.3.3/tagulous/serializers/ 0000775 0000000 0000000 00000000000 14161666113 0021025 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/tagulous/serializers/__init__.py 0000664 0000000 0000000 00000000000 14161666113 0023124 0 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/tagulous/serializers/base.py 0000664 0000000 0000000 00000004401 14161666113 0022310 0 ustar 00root root 0000000 0000000 """
Extensions for serializers to add tag field support
"""
from ..models.fields import SingleTagField, TagField
from ..models.tagged import TaggedModel
class SerializerMixin(object):
"""
Mixin for any Serializer which doesn't define its own handle_fk_field or
handle_m2m_field, to add tag support
"""
def handle_fk_field(self, obj, field):
if isinstance(field, SingleTagField):
self._current[field.name] = str(getattr(obj, field.name))
else:
super(SerializerMixin, self).handle_fk_field(obj, field)
def handle_m2m_field(self, obj, field):
if isinstance(field, TagField):
self._current[field.name] = [
tag.name for tag in getattr(obj, field.name).all()
]
else:
super(SerializerMixin, self).handle_m2m_field(obj, field)
def _deserialize_obj(obj):
"""
Given a DeserializationObject, deserialise any tag fields
"""
# Convert any tag fields from m2m to string assignments
Model = obj.object.__class__
if hasattr(Model, "_retag_to_original"):
obj.object = obj.object._retag_to_original()
return obj
def DeserializerWrapper(deserializer, doc=None):
"""
Adds tag support to any deserializer which yields DeserializedObjects
Given a deserializer, it modifies the DeserializedObjects which would
normally be returned so tag fields are deserialized correctly.
"""
def wrapper(object_list, **options):
# Call normal deserializer, get generator of DeserializedObjects
obj_generator = deserializer(object_list, **options)
for obj in obj_generator:
yield _deserialize_obj(obj)
if doc:
wrapper.__doc__ = doc
return wrapper
def monkeypatch_get_model(serializer):
"""
Given a model identifier, get the model - unless it's a TaggedModel, in
which case return a temporary fake model to get it serialized.
"""
old_get_model = serializer._get_model
def _get_model(model_identifier):
RealModel = old_get_model(model_identifier)
if issubclass(RealModel, TaggedModel):
Model = RealModel._detag_to_serializable()
else:
Model = RealModel
return Model
serializer._get_model = _get_model
django-tagulous-1.3.3/tagulous/serializers/json.py 0000664 0000000 0000000 00000000647 14161666113 0022357 0 ustar 00root root 0000000 0000000 """
JSON serializer with Tagulous support
"""
from django.core.serializers import json as json_serializer
from . import base
class Serializer(base.SerializerMixin, json_serializer.Serializer):
"""
JSON serializer with tag field support
"""
pass
Deserializer = base.DeserializerWrapper(
json_serializer.Deserializer,
doc="Deserialize a stream or string of JSON data, with tag field support",
)
django-tagulous-1.3.3/tagulous/serializers/python.py 0000664 0000000 0000000 00000001043 14161666113 0022716 0 ustar 00root root 0000000 0000000 """
Python serializer with Tagulous support
"""
from django.core.serializers import python as python_serializer
from . import base
class Serializer(base.SerializerMixin, python_serializer.Serializer):
"""
Serializes a QuerySet to basic Python objects, with tag field support
"""
pass
Deserializer = base.DeserializerWrapper(
python_serializer.Deserializer,
doc=(
"Deserialize Python objects into Django ORM instances, with tag field "
"support"
),
)
base.monkeypatch_get_model(python_serializer)
django-tagulous-1.3.3/tagulous/serializers/pyyaml.py 0000664 0000000 0000000 00000000657 14161666113 0022722 0 ustar 00root root 0000000 0000000 """
YAML serializer with Tagulous support
"""
from django.core.serializers import pyyaml as pyyaml_serializer
from . import base
class Serializer(base.SerializerMixin, pyyaml_serializer.Serializer):
"""
YAML serializer with tag field support
"""
pass
Deserializer = base.DeserializerWrapper(
pyyaml_serializer.Deserializer,
doc="Deserialize a stream or string of YAML data, with tag field support",
)
django-tagulous-1.3.3/tagulous/serializers/xml_serializer.py 0000664 0000000 0000000 00000004452 14161666113 0024435 0 ustar 00root root 0000000 0000000 """
XML serializer with Tagulous support
"""
from django.core.serializers import xml_serializer
from ..models.fields import SingleTagField, TagField
from ..models.tagged import TaggedModel
from . import base
class FakeObject(object):
"""
Fake object to feed into the standard XML serializer, to trick it into
serializing a tag field as a text field
"""
def __init__(self, field_name, value):
setattr(self, field_name, value)
self.value = value
class FakeField(object):
"""
Fake field to feed into the standard XML serializer, to trick it into
serializing a tag field as a text field
"""
def __init__(self, name):
self.name = name
def get_internal_type(self):
return "TextField"
def value_to_string(self, obj):
return obj.value
class Serializer(xml_serializer.Serializer):
"""
XML serializer with tag field support
"""
def handle_tagfield(self, obj, field):
"""
Trick XML serializer into serializing this as text
"""
tag_string = str(getattr(obj, field.name))
fake_obj = FakeObject(field.name, tag_string)
fake_field = FakeField(field.name)
self.handle_field(fake_obj, fake_field)
def handle_fk_field(self, obj, field):
if isinstance(field, SingleTagField):
self.handle_tagfield(obj, field)
else:
super(Serializer, self).handle_fk_field(obj, field)
def handle_m2m_field(self, obj, field):
if isinstance(field, TagField):
self.handle_tagfield(obj, field)
else:
super(Serializer, self).handle_m2m_field(obj, field)
class Deserializer(xml_serializer.Deserializer):
def _handle_object(self, node):
obj = super(Deserializer, self)._handle_object(node)
return base._deserialize_obj(obj)
# Could override _handle_fk_field_node and _handle_m2m_field_node with
# code to check for tag fields, but the code to turn them into fake
# textfields is already in place
def _get_model_from_node(self, node, attr):
RealModel = super(Deserializer, self)._get_model_from_node(node, attr)
if issubclass(RealModel, TaggedModel):
Model = RealModel._detag_to_serializable()
else:
Model = RealModel
return Model
django-tagulous-1.3.3/tagulous/settings.py 0000664 0000000 0000000 00000005102 14161666113 0020701 0 ustar 00root root 0000000 0000000 """
Tagulous default settings
Override these by setting new values in your global settings file
"""
from django.conf import settings
#
# Database control settings
#
NAME_MAX_LENGTH = getattr(settings, "TAGULOUS_NAME_MAX_LENGTH", 255)
SLUG_MAX_LENGTH = getattr(settings, "TAGULOUS_SLUG_MAX_LENGTH", 50)
LABEL_MAX_LENGTH = getattr(settings, "TAGULOUS_LABEL_MAX_LENGTH", NAME_MAX_LENGTH)
# Number of characters to allow for finding a unique slug, ie if set to 5, the
# slug will be truncated by up to 5 characters to allow for a suffix of _9999
SLUG_TRUNCATE_UNIQUE = getattr(settings, "TAGULOUS_SLUG_TRUNCATE_UNIQUE", 5)
# Set to false to generate ASCII slugs
SLUG_ALLOW_UNICODE = getattr(settings, "TAGULOUS_SLUG_ALLOW_UNICODE", False)
#
# Autocomplete settings
#
DEFAULT_AUTOCOMPLETE_JS = (
"tagulous/lib/jquery.js",
"tagulous/lib/select2-4/js/select2.full.min.js",
"tagulous/tagulous.js",
"tagulous/adaptor/select2-4.js",
)
DEFAULT_AUTOCOMPLETE_CSS = {"all": ["tagulous/lib/select2-4/css/select2.min.css"]}
AUTOCOMPLETE_JS = getattr(settings, "TAGULOUS_AUTOCOMPLETE_JS", DEFAULT_AUTOCOMPLETE_JS)
AUTOCOMPLETE_CSS = getattr(
settings, "TAGULOUS_AUTOCOMPLETE_CSS", DEFAULT_AUTOCOMPLETE_CSS
)
AUTOCOMPLETE_SETTINGS = getattr(settings, "TAGULOUS_AUTOCOMPLETE_SETTINGS", None)
# Use vendored jquery and select2 for admin
DEFAULT_ADMIN_AUTOCOMPLETE_JS = (
"tagulous/tagulous.js",
"tagulous/adaptor/select2-4.js",
)
DEFAULT_ADMIN_AUTOCOMPLETE_CSS = {}
ADMIN_AUTOCOMPLETE_JS = getattr(
settings, "TAGULOUS_ADMIN_AUTOCOMPLETE_JS", DEFAULT_ADMIN_AUTOCOMPLETE_JS
)
ADMIN_AUTOCOMPLETE_CSS = getattr(
settings, "TAGULOUS_ADMIN_AUTOCOMPLETE_CSS", DEFAULT_ADMIN_AUTOCOMPLETE_CSS
)
ADMIN_AUTOCOMPLETE_SETTINGS = getattr(
settings, "TAGULOUS_ADMIN_AUTOCOMPLETE_SETTINGS", AUTOCOMPLETE_SETTINGS
)
#
# Tag weighting defaults, for tag model queryset .weight() method
#
WEIGHT_MIN = getattr(settings, "TAGULOUS_WEIGHT_MIN", 1)
WEIGHT_MAX = getattr(settings, "TAGULOUS_WEIGHT_MAX", 6)
#
# Feature flags
#
# Option to automatically enhance Model, Manager and QuerySet classes so they
# know how to work with SingleTagFields and TagFields.
#
# This will automatically change models which use tag fields to subclass
# TaggedModel, their managers to subclass TaggedManager, and their querysets to
# subclass TaggedQuerySet
#
# If this is set to False, certain aspects of tag fields will not work as
# expected; you should consider manually subclassing the relevant classes.
# See settings documentation for more information.
ENHANCE_MODELS = getattr(settings, "TAGULOUS_ENHANCE_MODELS", True)
django-tagulous-1.3.3/tagulous/signals/ 0000775 0000000 0000000 00000000000 14161666113 0020131 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/tagulous/signals/__init__.py 0000664 0000000 0000000 00000000000 14161666113 0022230 0 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/tagulous/signals/post.py 0000664 0000000 0000000 00000007412 14161666113 0021474 0 ustar 00root root 0000000 0000000 """
Model signal handlers
These are connected in tagulous.apps.TagulousConfig.ready()
"""
from ..models.fields import SingleTagField, TagField
from ..models.tagged import TaggedModel
class TaggedSignalHandler(object):
"""
Base class handling signals from TaggedModel subclasses
"""
def __call__(self, sender, instance, **kwargs):
if not self.is_relevant(sender):
return
for field, field_type in self.get_fields(sender):
descriptor = getattr(sender, field.name)
manager = descriptor.get_manager(instance)
self.handle(manager, field_type, kwargs.get("raw", False))
def is_relevant(self, sender):
return issubclass(sender, TaggedModel)
def get_fields(self, sender):
"""
Generator which returns (field, field_type) pairs
"""
for field in sender._meta.get_fields():
if isinstance(field, SingleTagField):
yield (field, SingleTagField)
elif isinstance(field, TagField):
yield (field, TagField)
def handle(self, manager, field_type, is_raw):
raise NotImplementedError() # pragma: no cover
class PreSaveHandler(TaggedSignalHandler):
"""
Pre-save signal handler
Make sure SingleTagField is in correct format to be saved. The manager needs to know
when the model is about to be saved # so that it can ensure the tag exists and
assign its pk to field_id.
"""
def handle(self, manager, field_type, is_raw):
if field_type != SingleTagField:
return
manager.pre_save_handler()
class PostSaveHandler(TaggedSignalHandler):
"""
Post-save signal handler
Ensure both tag fields' states are saved
"""
def handle(self, manager, field_type, is_raw):
manager.post_save_handler()
# If raw is set, data is being injected into the system, most likely from a
# deserialization operation. If the tag model has just been deserialized too,
# the tag counts will probably be off.
if is_raw:
if field_type == SingleTagField:
manager.get().update_count()
else:
for tag in manager.tags:
tag.update_count()
class PropagatedSignalMixin(object):
def get_fields(self, sender):
"""
Post delete signal propagates up the class hierarchy, so filter fields
returned to those belonging to the model which raised this signal
"""
for field, field_type in super(PropagatedSignalMixin, self).get_fields(sender):
if field.model != sender:
continue
yield (field, field_type)
class PreDeleteHandler(PropagatedSignalMixin, TaggedSignalHandler):
"""
Pre-delete signal handler
Ensure TagField is cleaned out before the main object is deleted
"""
def handle(self, manager, field_type, is_raw):
if field_type != TagField:
return
manager.pre_delete_handler()
class PostDeleteHandler(PropagatedSignalMixin, TaggedSignalHandler):
"""
Post-delete signal handler
Update tag count on delete
"""
def handle(self, manager, field_type, is_raw):
if field_type != SingleTagField:
return
manager.post_delete_handler()
def register_post_signals():
from django.db.models.signals import post_delete, post_save, pre_delete, pre_save
pre_save.connect(PreSaveHandler(), weak=False, dispatch_uid="tagulous_pre_save")
post_save.connect(PostSaveHandler(), weak=False, dispatch_uid="tagulous_post_save")
pre_delete.connect(
PreDeleteHandler(), weak=False, dispatch_uid="tagulous_pre_delete"
)
post_delete.connect(
PostDeleteHandler(), weak=False, dispatch_uid="tagulous_post_delete"
)
django-tagulous-1.3.3/tagulous/signals/pre.py 0000664 0000000 0000000 00000001247 14161666113 0021275 0 ustar 00root root 0000000 0000000 """
Signals registered before models are loaded
These are registered as part of Tagulous model initialisation, so apps following this in
INSTALLED_APPS can have their models enhanced.
"""
from django.db.models.signals import class_prepared
from .. import settings
from ..models.tagged import TaggedModel
def class_prepared_listener(sender, **kwargs):
"""
Listen to the class_prepared signal and subclass any model with tag
fields
"""
TaggedModel.cast_class(sender)
def register_pre_signals():
"""
Called from tagulous/models/__init__.py
"""
if settings.ENHANCE_MODELS:
class_prepared.connect(class_prepared_listener, weak=False)
django-tagulous-1.3.3/tagulous/static/ 0000775 0000000 0000000 00000000000 14161666113 0017760 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/tagulous/static/tagulous/ 0000775 0000000 0000000 00000000000 14161666113 0021623 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/tagulous/static/tagulous/adaptor/ 0000775 0000000 0000000 00000000000 14161666113 0023255 5 ustar 00root root 0000000 0000000 django-tagulous-1.3.3/tagulous/static/tagulous/adaptor/select2-3.js 0000664 0000000 0000000 00000020453 14161666113 0025320 0 ustar 00root root 0000000 0000000 /** Tagulous adaptor for Select2 v3 */
(function ($) {
if (!window.Select2 || !window.Tagulous) {
return;
}
/** Select2 monkeypatching
Adds support for new option, quotedTags
This is used by tagulous to add quote support to the tag parser,
without affecting other use of select2 on the page.
*/
var MultiSelect2 = Select2['class'].multi,
oldGetVal = MultiSelect2.prototype.getVal,
oldSetVal = MultiSelect2.prototype.setVal
;
MultiSelect2.prototype.getVal = function () {
/** Parse tag string into tags */
if (this.select || !this.opts.quotedTags) {
return oldGetVal.call(this);
}
return Tagulous.parseTags(
this.opts.element.val(), this.opts.spaceDelimiter
);
};
MultiSelect2.prototype.setVal = function (val) {
/** Join tags into a string */
if (this.select || !this.opts.quotedTags) {
return oldSetVal.call(this, val);
}
var str = Tagulous.renderTags(val);
this.opts.element.val(str);
};
/** Select2 option functions
These replace default options with quote-aware ones
*/
function initSelectionSingle(element, callback) {
var val = element.val();
callback({id: val, text: val});
}
function initSelectionMulti_factory(opts) {
/** initSelection has no way to get options, so need to use closure */
return function (element, callback) {
/** Initialises selection for fields with multiple tags */
var tags = Tagulous.parseTags(element.val(), opts.spaceDelimiter),
data = [],
i
;
for (i=0; i 0 && // there are quotes
numEndQuotes > 0 &&
numStartQuotes + numEndQuotes < term.length && // something other than quotes
numStartQuotes % 2 == 1 && // uneven quotes, so one is unescaped
numEndQuotes % 2 == 1
) {
params.term = term.substr(1, term.length - 2);
}
return decorated.call(this, params);
}
// Rather than re-implement Default.prototype.apply logic to determine the correct
// data adapter base classes so we can pass it in as options.dataAdapter, we'll just
// monkeypatch Default.apply so we can add our data adapter extension at the end.
// There might be a nicer way to do this, PRs welcome!
var oldApply = defaults.apply
defaults.apply = function (options) {
options = oldApply.call(this, options);
options.dataAdapter = Utils.Decorate(options.dataAdapter, TagulousDataAdapter);
return options
};
/** Apply select2 to a specified element
Arguments:
el The DOM or jQuery object to use as the tag element
canDefer If true and tag-options.defer is set, this field
will not be initialised.
*/
function apply_select2(el, canDefer) {
// Convert element to jQuery object (if it isn't already)
var $el = $(el),
thisTagField = this,
// Get info from element
isSingle = $el.data('tag-type') === "single",
options = $el.data('tag-options') || {},
settings = options.autocomplete_settings || {},
list = $el.data('tag-list'),
url = $el.data('tag-url'),
// Other values
$blank, args, field_args
;
// See if this is a deferred tag
if (canDefer && settings.defer) {
return $el;
}
delete settings.defer;
// Clear out first option if it's Django's blank value
$blank = $el
.find('option:first[value=""]:contains("---------")')
.text('')
;
// Default constructor args, which can be overridden
args = {
width: 'resolve'
};
// Merge in any overrides
field_args = settings;
if (field_args) {
$.extend(args, field_args);
}
// Merge in common compulsory settings
$.extend(args, {
// Select2 options
tokenizer: tokenizer,
tags: true,
// Things defined by field/tag options, which can't be overridden
multiple: !isSingle,
quotedTags: true,
allowClear: !options.required,
maximumSelectionLength: isSingle ? null : options.max_count || null,
spaceDelimiter: options.space_delimiter !== false
});
// Add in any specific to the field type
if (url) {
args['ajax'] = {
url: url,
dataType: 'json',
data: function (params) {
return {q:params.term, p:params.page};
},
processResults: function (data) {
data['results'] = listToData(data['results']);
return data;
}
};
// Merge in override ajax values
if (field_args && field_args.ajax) {
$.extend(args['ajax'], field_args.ajax);
}
} else if (isSingle) {
// Make SingleTagField look like a select, set data not tags
args['data'] = listToData(list);
// Add a placeholder to ignore the empty option we're about to add
args['placeholder'] = $el.prop('placeholder') || "";
} else {
// Multiple tags, normal tags mode appropriate
$.extend(args, {
data: list || [],
});
}
// Collect values
var currentVal = $el.val();
var selectedTags = [];
if (isSingle) {
if (currentVal) {
selectedTags = [currentVal];
}
} else {
selectedTags = Tagulous.parseTags(currentVal, args.spaceDelimiter);
}
/**
* Convert to "]);var me=/<|&#?\w+;/;function xe(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d\s*$/g;function je(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function De(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function qe(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Le(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,"handle events"),s)for(n=0,r=s[i].length;n").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var _t,zt=[],Ut=/(=)\?(?=&|$)|\?\?/;S.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=zt.pop()||S.expando+"_"+wt.guid++;return this[e]=!0,e}}),S.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Ut.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Ut.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Ut,"$1"+r):!1!==e.jsonp&&(e.url+=(Tt.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||S.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?S(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,zt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((_t=E.implementation.createHTMLDocument("").body).innerHTML="",2===_t.childNodes.length),S.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=N.exec(e))?[t.createElement(i[1])]:(i=xe([e],t,o),o&&o.length&&S(o).remove(),S.merge([],i.childNodes)));var r,i,o},S.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1").append(S.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},S.expr.pseudos.animated=function(t){return S.grep(S.timers,function(e){return t===e.elem}).length},S.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=S.css(e,"position"),c=S(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=S.css(e,"top"),u=S.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,S.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},S.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){S.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===S.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===S.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=S(e).offset()).top+=S.css(e,"borderTopWidth",!0),i.left+=S.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-S.css(r,"marginTop",!0),left:t.left-i.left-S.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===S.css(e,"position"))e=e.offsetParent;return e||re})}}),S.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;S.fn[t]=function(e){return $(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),S.each(["top","left"],function(e,n){S.cssHooks[n]=Fe(y.pixelPosition,function(e,t){if(t)return t=We(e,n),Pe.test(t)?S(e).position()[n]+"px":t})}),S.each({Height:"height",Width:"width"},function(a,s){S.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){S.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return $(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?S.css(e,t,i):S.style(e,t,n,i)},s,n?e:void 0,n)}})}),S.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){S.fn[t]=function(e){return this.on(t,e)}}),S.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),S.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){S.fn[n]=function(e,t){return 0_\'Gm7$+! !
, w Ie9*, (*(B5[1 ZIah!GexzJ0e6@V|U4Dm%$͛p
\G x
} @+| =+
1- Ea5l)+! !
, y )䨞'AKڍ,E\(l&;5 5D0 3a0-- ÃpH4V %
i
p[R"| #
6iZwcw*! !
, y )䨞,K*0 a;аY8b`4n ¨Bb bx ,( Ƚ %
>
2*i* /:+$v*! !
, u )䨞l[$
Jq[q 3`Q[5:IX!0rAD8 CvHPfii QAP@pC
%D
PQ46
iciNj0w
)#! !
, y ). q
,G J r( J8 C*B,&<
h W~-`, ,>;
8RN<, <1T]
c'
qk$
@)#! ; django-tagulous-1.3.3/tagulous/static/tagulous/lib/select2-3/select2.css 0000664 0000000 0000000 00000046001 14161666113 0026146 0 ustar 00root root 0000000 0000000 /*
Version: 3.5.2 Timestamp: Sat Nov 1 14:43:36 EDT 2014
*/
.select2-container {
margin: 0;
position: relative;
display: inline-block;
/* inline-block for ie7 */
zoom: 1;
*display: inline;
vertical-align: middle;
}
.select2-container,
.select2-drop,
.select2-search,
.select2-search input {
/*
Force border-box so that % widths fit the parent
container without overlap because of margin/padding.
More Info : http://www.quirksmode.org/css/box.html
*/
-webkit-box-sizing: border-box; /* webkit */
-moz-box-sizing: border-box; /* firefox */
box-sizing: border-box; /* css3 */
}
.select2-container .select2-choice {
display: block;
height: 26px;
padding: 0 0 0 8px;
overflow: hidden;
position: relative;
border: 1px solid #aaa;
white-space: nowrap;
line-height: 26px;
color: #444;
text-decoration: none;
border-radius: 4px;
background-clip: padding-box;
-webkit-touch-callout: none;
-webkit-user-select: none;
-moz-user-select: none;
-ms-user-select: none;
user-select: none;
background-color: #fff;
background-image: -webkit-gradient(linear, left bottom, left top, color-stop(0, #eee), color-stop(0.5, #fff));
background-image: -webkit-linear-gradient(center bottom, #eee 0%, #fff 50%);
background-image: -moz-linear-gradient(center bottom, #eee 0%, #fff 50%);
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr = '#ffffff', endColorstr = '#eeeeee', GradientType = 0);
background-image: linear-gradient(to top, #eee 0%, #fff 50%);
}
html[dir="rtl"] .select2-container .select2-choice {
padding: 0 8px 0 0;
}
.select2-container.select2-drop-above .select2-choice {
border-bottom-color: #aaa;
border-radius: 0 0 4px 4px;
background-image: -webkit-gradient(linear, left bottom, left top, color-stop(0, #eee), color-stop(0.9, #fff));
background-image: -webkit-linear-gradient(center bottom, #eee 0%, #fff 90%);
background-image: -moz-linear-gradient(center bottom, #eee 0%, #fff 90%);
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffff', endColorstr='#eeeeee', GradientType=0);
background-image: linear-gradient(to bottom, #eee 0%, #fff 90%);
}
.select2-container.select2-allowclear .select2-choice .select2-chosen {
margin-right: 42px;
}
.select2-container .select2-choice > .select2-chosen {
margin-right: 26px;
display: block;
overflow: hidden;
white-space: nowrap;
text-overflow: ellipsis;
float: none;
width: auto;
}
html[dir="rtl"] .select2-container .select2-choice > .select2-chosen {
margin-left: 26px;
margin-right: 0;
}
.select2-container .select2-choice abbr {
display: none;
width: 12px;
height: 12px;
position: absolute;
right: 24px;
top: 8px;
font-size: 1px;
text-decoration: none;
border: 0;
background: url('select2.png') right top no-repeat;
cursor: pointer;
outline: 0;
}
.select2-container.select2-allowclear .select2-choice abbr {
display: inline-block;
}
.select2-container .select2-choice abbr:hover {
background-position: right -11px;
cursor: pointer;
}
.select2-drop-mask {
border: 0;
margin: 0;
padding: 0;
position: fixed;
left: 0;
top: 0;
min-height: 100%;
min-width: 100%;
height: auto;
width: auto;
opacity: 0;
z-index: 9998;
/* styles required for IE to work */
background-color: #fff;
filter: alpha(opacity=0);
}
.select2-drop {
width: 100%;
margin-top: -1px;
position: absolute;
z-index: 9999;
top: 100%;
background: #fff;
color: #000;
border: 1px solid #aaa;
border-top: 0;
border-radius: 0 0 4px 4px;
-webkit-box-shadow: 0 4px 5px rgba(0, 0, 0, .15);
box-shadow: 0 4px 5px rgba(0, 0, 0, .15);
}
.select2-drop.select2-drop-above {
margin-top: 1px;
border-top: 1px solid #aaa;
border-bottom: 0;
border-radius: 4px 4px 0 0;
-webkit-box-shadow: 0 -4px 5px rgba(0, 0, 0, .15);
box-shadow: 0 -4px 5px rgba(0, 0, 0, .15);
}
.select2-drop-active {
border: 1px solid #5897fb;
border-top: none;
}
.select2-drop.select2-drop-above.select2-drop-active {
border-top: 1px solid #5897fb;
}
.select2-drop-auto-width {
border-top: 1px solid #aaa;
width: auto;
}
.select2-drop-auto-width .select2-search {
padding-top: 4px;
}
.select2-container .select2-choice .select2-arrow {
display: inline-block;
width: 18px;
height: 100%;
position: absolute;
right: 0;
top: 0;
border-left: 1px solid #aaa;
border-radius: 0 4px 4px 0;
background-clip: padding-box;
background: #ccc;
background-image: -webkit-gradient(linear, left bottom, left top, color-stop(0, #ccc), color-stop(0.6, #eee));
background-image: -webkit-linear-gradient(center bottom, #ccc 0%, #eee 60%);
background-image: -moz-linear-gradient(center bottom, #ccc 0%, #eee 60%);
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr = '#eeeeee', endColorstr = '#cccccc', GradientType = 0);
background-image: linear-gradient(to top, #ccc 0%, #eee 60%);
}
html[dir="rtl"] .select2-container .select2-choice .select2-arrow {
left: 0;
right: auto;
border-left: none;
border-right: 1px solid #aaa;
border-radius: 4px 0 0 4px;
}
.select2-container .select2-choice .select2-arrow b {
display: block;
width: 100%;
height: 100%;
background: url('select2.png') no-repeat 0 1px;
}
html[dir="rtl"] .select2-container .select2-choice .select2-arrow b {
background-position: 2px 1px;
}
.select2-search {
display: inline-block;
width: 100%;
min-height: 26px;
margin: 0;
padding-left: 4px;
padding-right: 4px;
position: relative;
z-index: 10000;
white-space: nowrap;
}
.select2-search input {
width: 100%;
height: auto !important;
min-height: 26px;
padding: 4px 20px 4px 5px;
margin: 0;
outline: 0;
font-family: sans-serif;
font-size: 1em;
border: 1px solid #aaa;
border-radius: 0;
-webkit-box-shadow: none;
box-shadow: none;
background: #fff url('select2.png') no-repeat 100% -22px;
background: url('select2.png') no-repeat 100% -22px, -webkit-gradient(linear, left bottom, left top, color-stop(0.85, #fff), color-stop(0.99, #eee));
background: url('select2.png') no-repeat 100% -22px, -webkit-linear-gradient(center bottom, #fff 85%, #eee 99%);
background: url('select2.png') no-repeat 100% -22px, -moz-linear-gradient(center bottom, #fff 85%, #eee 99%);
background: url('select2.png') no-repeat 100% -22px, linear-gradient(to bottom, #fff 85%, #eee 99%) 0 0;
}
html[dir="rtl"] .select2-search input {
padding: 4px 5px 4px 20px;
background: #fff url('select2.png') no-repeat -37px -22px;
background: url('select2.png') no-repeat -37px -22px, -webkit-gradient(linear, left bottom, left top, color-stop(0.85, #fff), color-stop(0.99, #eee));
background: url('select2.png') no-repeat -37px -22px, -webkit-linear-gradient(center bottom, #fff 85%, #eee 99%);
background: url('select2.png') no-repeat -37px -22px, -moz-linear-gradient(center bottom, #fff 85%, #eee 99%);
background: url('select2.png') no-repeat -37px -22px, linear-gradient(to bottom, #fff 85%, #eee 99%) 0 0;
}
.select2-drop.select2-drop-above .select2-search input {
margin-top: 4px;
}
.select2-search input.select2-active {
background: #fff url('select2-spinner.gif') no-repeat 100%;
background: url('select2-spinner.gif') no-repeat 100%, -webkit-gradient(linear, left bottom, left top, color-stop(0.85, #fff), color-stop(0.99, #eee));
background: url('select2-spinner.gif') no-repeat 100%, -webkit-linear-gradient(center bottom, #fff 85%, #eee 99%);
background: url('select2-spinner.gif') no-repeat 100%, -moz-linear-gradient(center bottom, #fff 85%, #eee 99%);
background: url('select2-spinner.gif') no-repeat 100%, linear-gradient(to bottom, #fff 85%, #eee 99%) 0 0;
}
.select2-container-active .select2-choice,
.select2-container-active .select2-choices {
border: 1px solid #5897fb;
outline: none;
-webkit-box-shadow: 0 0 5px rgba(0, 0, 0, .3);
box-shadow: 0 0 5px rgba(0, 0, 0, .3);
}
.select2-dropdown-open .select2-choice {
border-bottom-color: transparent;
-webkit-box-shadow: 0 1px 0 #fff inset;
box-shadow: 0 1px 0 #fff inset;
border-bottom-left-radius: 0;
border-bottom-right-radius: 0;
background-color: #eee;
background-image: -webkit-gradient(linear, left bottom, left top, color-stop(0, #fff), color-stop(0.5, #eee));
background-image: -webkit-linear-gradient(center bottom, #fff 0%, #eee 50%);
background-image: -moz-linear-gradient(center bottom, #fff 0%, #eee 50%);
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#eeeeee', endColorstr='#ffffff', GradientType=0);
background-image: linear-gradient(to top, #fff 0%, #eee 50%);
}
.select2-dropdown-open.select2-drop-above .select2-choice,
.select2-dropdown-open.select2-drop-above .select2-choices {
border: 1px solid #5897fb;
border-top-color: transparent;
background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0, #fff), color-stop(0.5, #eee));
background-image: -webkit-linear-gradient(center top, #fff 0%, #eee 50%);
background-image: -moz-linear-gradient(center top, #fff 0%, #eee 50%);
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#eeeeee', endColorstr='#ffffff', GradientType=0);
background-image: linear-gradient(to bottom, #fff 0%, #eee 50%);
}
.select2-dropdown-open .select2-choice .select2-arrow {
background: transparent;
border-left: none;
filter: none;
}
html[dir="rtl"] .select2-dropdown-open .select2-choice .select2-arrow {
border-right: none;
}
.select2-dropdown-open .select2-choice .select2-arrow b {
background-position: -18px 1px;
}
html[dir="rtl"] .select2-dropdown-open .select2-choice .select2-arrow b {
background-position: -16px 1px;
}
.select2-hidden-accessible {
border: 0;
clip: rect(0 0 0 0);
height: 1px;
margin: -1px;
overflow: hidden;
padding: 0;
position: absolute;
width: 1px;
}
/* results */
.select2-results {
max-height: 200px;
padding: 0 0 0 4px;
margin: 4px 4px 4px 0;
position: relative;
overflow-x: hidden;
overflow-y: auto;
-webkit-tap-highlight-color: rgba(0, 0, 0, 0);
}
html[dir="rtl"] .select2-results {
padding: 0 4px 0 0;
margin: 4px 0 4px 4px;
}
.select2-results ul.select2-result-sub {
margin: 0;
padding-left: 0;
}
.select2-results li {
list-style: none;
display: list-item;
background-image: none;
}
.select2-results li.select2-result-with-children > .select2-result-label {
font-weight: bold;
}
.select2-results .select2-result-label {
padding: 3px 7px 4px;
margin: 0;
cursor: pointer;
min-height: 1em;
-webkit-touch-callout: none;
-webkit-user-select: none;
-moz-user-select: none;
-ms-user-select: none;
user-select: none;
}
.select2-results-dept-1 .select2-result-label { padding-left: 20px }
.select2-results-dept-2 .select2-result-label { padding-left: 40px }
.select2-results-dept-3 .select2-result-label { padding-left: 60px }
.select2-results-dept-4 .select2-result-label { padding-left: 80px }
.select2-results-dept-5 .select2-result-label { padding-left: 100px }
.select2-results-dept-6 .select2-result-label { padding-left: 110px }
.select2-results-dept-7 .select2-result-label { padding-left: 120px }
.select2-results .select2-highlighted {
background: #3875d7;
color: #fff;
}
.select2-results li em {
background: #feffde;
font-style: normal;
}
.select2-results .select2-highlighted em {
background: transparent;
}
.select2-results .select2-highlighted ul {
background: #fff;
color: #000;
}
.select2-results .select2-no-results,
.select2-results .select2-searching,
.select2-results .select2-ajax-error,
.select2-results .select2-selection-limit {
background: #f4f4f4;
display: list-item;
padding-left: 5px;
}
/*
disabled look for disabled choices in the results dropdown
*/
.select2-results .select2-disabled.select2-highlighted {
color: #666;
background: #f4f4f4;
display: list-item;
cursor: default;
}
.select2-results .select2-disabled {
background: #f4f4f4;
display: list-item;
cursor: default;
}
.select2-results .select2-selected {
display: none;
}
.select2-more-results.select2-active {
background: #f4f4f4 url('select2-spinner.gif') no-repeat 100%;
}
.select2-results .select2-ajax-error {
background: rgba(255, 50, 50, .2);
}
.select2-more-results {
background: #f4f4f4;
display: list-item;
}
/* disabled styles */
.select2-container.select2-container-disabled .select2-choice {
background-color: #f4f4f4;
background-image: none;
border: 1px solid #ddd;
cursor: default;
}
.select2-container.select2-container-disabled .select2-choice .select2-arrow {
background-color: #f4f4f4;
background-image: none;
border-left: 0;
}
.select2-container.select2-container-disabled .select2-choice abbr {
display: none;
}
/* multiselect */
.select2-container-multi .select2-choices {
height: auto !important;
height: 1%;
margin: 0;
padding: 0 5px 0 0;
position: relative;
border: 1px solid #aaa;
cursor: text;
overflow: hidden;
background-color: #fff;
background-image: -webkit-gradient(linear, 0% 0%, 0% 100%, color-stop(1%, #eee), color-stop(15%, #fff));
background-image: -webkit-linear-gradient(top, #eee 1%, #fff 15%);
background-image: -moz-linear-gradient(top, #eee 1%, #fff 15%);
background-image: linear-gradient(to bottom, #eee 1%, #fff 15%);
}
html[dir="rtl"] .select2-container-multi .select2-choices {
padding: 0 0 0 5px;
}
.select2-locked {
padding: 3px 5px 3px 5px !important;
}
.select2-container-multi .select2-choices {
min-height: 26px;
}
.select2-container-multi.select2-container-active .select2-choices {
border: 1px solid #5897fb;
outline: none;
-webkit-box-shadow: 0 0 5px rgba(0, 0, 0, .3);
box-shadow: 0 0 5px rgba(0, 0, 0, .3);
}
.select2-container-multi .select2-choices li {
float: left;
list-style: none;
}
html[dir="rtl"] .select2-container-multi .select2-choices li
{
float: right;
}
.select2-container-multi .select2-choices .select2-search-field {
margin: 0;
padding: 0;
white-space: nowrap;
}
.select2-container-multi .select2-choices .select2-search-field input {
padding: 5px;
margin: 1px 0;
font-family: sans-serif;
font-size: 100%;
color: #666;
outline: 0;
border: 0;
-webkit-box-shadow: none;
box-shadow: none;
background: transparent !important;
}
.select2-container-multi .select2-choices .select2-search-field input.select2-active {
background: #fff url('select2-spinner.gif') no-repeat 100% !important;
}
.select2-default {
color: #999 !important;
}
.select2-container-multi .select2-choices .select2-search-choice {
padding: 3px 5px 3px 18px;
margin: 3px 0 3px 5px;
position: relative;
line-height: 13px;
color: #333;
cursor: default;
border: 1px solid #aaaaaa;
border-radius: 3px;
-webkit-box-shadow: 0 0 2px #fff inset, 0 1px 0 rgba(0, 0, 0, 0.05);
box-shadow: 0 0 2px #fff inset, 0 1px 0 rgba(0, 0, 0, 0.05);
background-clip: padding-box;
-webkit-touch-callout: none;
-webkit-user-select: none;
-moz-user-select: none;
-ms-user-select: none;
user-select: none;
background-color: #e4e4e4;
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#eeeeee', endColorstr='#f4f4f4', GradientType=0);
background-image: -webkit-gradient(linear, 0% 0%, 0% 100%, color-stop(20%, #f4f4f4), color-stop(50%, #f0f0f0), color-stop(52%, #e8e8e8), color-stop(100%, #eee));
background-image: -webkit-linear-gradient(top, #f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eee 100%);
background-image: -moz-linear-gradient(top, #f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eee 100%);
background-image: linear-gradient(to bottom, #f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eee 100%);
}
html[dir="rtl"] .select2-container-multi .select2-choices .select2-search-choice
{
margin: 3px 5px 3px 0;
padding: 3px 18px 3px 5px;
}
.select2-container-multi .select2-choices .select2-search-choice .select2-chosen {
cursor: default;
}
.select2-container-multi .select2-choices .select2-search-choice-focus {
background: #d4d4d4;
}
.select2-search-choice-close {
display: block;
width: 12px;
height: 13px;
position: absolute;
right: 3px;
top: 4px;
font-size: 1px;
outline: none;
background: url('select2.png') right top no-repeat;
}
html[dir="rtl"] .select2-search-choice-close {
right: auto;
left: 3px;
}
.select2-container-multi .select2-search-choice-close {
left: 3px;
}
html[dir="rtl"] .select2-container-multi .select2-search-choice-close {
left: auto;
right: 2px;
}
.select2-container-multi .select2-choices .select2-search-choice .select2-search-choice-close:hover {
background-position: right -11px;
}
.select2-container-multi .select2-choices .select2-search-choice-focus .select2-search-choice-close {
background-position: right -11px;
}
/* disabled styles */
.select2-container-multi.select2-container-disabled .select2-choices {
background-color: #f4f4f4;
background-image: none;
border: 1px solid #ddd;
cursor: default;
}
.select2-container-multi.select2-container-disabled .select2-choices .select2-search-choice {
padding: 3px 5px 3px 5px;
border: 1px solid #ddd;
background-image: none;
background-color: #f4f4f4;
}
.select2-container-multi.select2-container-disabled .select2-choices .select2-search-choice .select2-search-choice-close { display: none;
background: none;
}
/* end multiselect */
.select2-result-selectable .select2-match,
.select2-result-unselectable .select2-match {
text-decoration: underline;
}
.select2-offscreen, .select2-offscreen:focus {
clip: rect(0 0 0 0) !important;
width: 1px !important;
height: 1px !important;
border: 0 !important;
margin: 0 !important;
padding: 0 !important;
overflow: hidden !important;
position: absolute !important;
outline: 0 !important;
left: 0px !important;
top: 0px !important;
}
.select2-display-none {
display: none;
}
.select2-measure-scrollbar {
position: absolute;
top: -10000px;
left: -10000px;
width: 100px;
height: 100px;
overflow: scroll;
}
/* Retina-ize icons */
@media only screen and (-webkit-min-device-pixel-ratio: 1.5), only screen and (min-resolution: 2dppx) {
.select2-search input,
.select2-search-choice-close,
.select2-container .select2-choice abbr,
.select2-container .select2-choice .select2-arrow b {
background-image: url('select2x2.png') !important;
background-repeat: no-repeat !important;
background-size: 60px 40px !important;
}
.select2-search input {
background-position: 100% -21px !important;
}
}
django-tagulous-1.3.3/tagulous/static/tagulous/lib/select2-3/select2.min.js 0000664 0000000 0000000 00000202044 14161666113 0026555 0 ustar 00root root 0000000 0000000 /*
Copyright 2014 Igor Vaynberg
Version: 3.5.2 Timestamp: Sat Nov 1 14:43:36 EDT 2014
This software is licensed under the Apache License, Version 2.0 (the "Apache License") or the GNU
General Public License version 2 (the "GPL License"). You may choose either license to govern your
use of this software only upon the condition that you accept all of the terms of either the Apache
License or the GPL License.
You may obtain a copy of the Apache License and the GPL License at:
http://www.apache.org/licenses/LICENSE-2.0
http://www.gnu.org/licenses/gpl-2.0.html
Unless required by applicable law or agreed to in writing, software distributed under the Apache License
or the GPL Licesnse is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
either express or implied. See the Apache License and the GPL License for the specific language governing
permissions and limitations under the Apache License and the GPL License.
*/
!function(a){"undefined"==typeof a.fn.each2&&a.extend(a.fn,{each2:function(b){for(var c=a([0]),d=-1,e=this.length;++dc;c+=1)if(r(a,b[c]))return c;return-1}function q(){var b=a(l);b.appendTo(document.body);var c={width:b.width()-b[0].clientWidth,height:b.height()-b[0].clientHeight};return b.remove(),c}function r(a,c){return a===c?!0:a===b||c===b?!1:null===a||null===c?!1:a.constructor===String?a+""==c+"":c.constructor===String?c+""==a+"":!1}function s(a,b,c){var d,e,f;if(null===a||a.length<1)return[];for(d=a.split(b),e=0,f=d.length;f>e;e+=1)d[e]=c(d[e]);return d}function t(a){return a.outerWidth(!1)-a.width()}function u(c){var d="keyup-change-value";c.on("keydown",function(){a.data(c,d)===b&&a.data(c,d,c.val())}),c.on("keyup",function(){var e=a.data(c,d);e!==b&&c.val()!==e&&(a.removeData(c,d),c.trigger("keyup-change"))})}function v(c){c.on("mousemove",function(c){var d=h;(d===b||d.x!==c.pageX||d.y!==c.pageY)&&a(c.target).trigger("mousemove-filtered",c)})}function w(a,c,d){d=d||b;var e;return function(){var b=arguments;window.clearTimeout(e),e=window.setTimeout(function(){c.apply(d,b)},a)}}function x(a,b){var c=w(a,function(a){b.trigger("scroll-debounced",a)});b.on("scroll",function(a){p(a.target,b.get())>=0&&c(a)})}function y(a){a[0]!==document.activeElement&&window.setTimeout(function(){var d,b=a[0],c=a.val().length;a.focus();var e=b.offsetWidth>0||b.offsetHeight>0;e&&b===document.activeElement&&(b.setSelectionRange?b.setSelectionRange(c,c):b.createTextRange&&(d=b.createTextRange(),d.collapse(!1),d.select()))},0)}function z(b){b=a(b)[0];var c=0,d=0;if("selectionStart"in b)c=b.selectionStart,d=b.selectionEnd-c;else if("selection"in document){b.focus();var e=document.selection.createRange();d=document.selection.createRange().text.length,e.moveStart("character",-b.value.length),c=e.text.length-d}return{offset:c,length:d}}function A(a){a.preventDefault(),a.stopPropagation()}function B(a){a.preventDefault(),a.stopImmediatePropagation()}function C(b){if(!g){var c=b[0].currentStyle||window.getComputedStyle(b[0],null);g=a(document.createElement("div")).css({position:"absolute",left:"-10000px",top:"-10000px",display:"none",fontSize:c.fontSize,fontFamily:c.fontFamily,fontStyle:c.fontStyle,fontWeight:c.fontWeight,letterSpacing:c.letterSpacing,textTransform:c.textTransform,whiteSpace:"nowrap"}),g.attr("class","select2-sizer"),a(document.body).append(g)}return g.text(b.val()),g.width()}function D(b,c,d){var e,g,f=[];e=a.trim(b.attr("class")),e&&(e=""+e,a(e.split(/\s+/)).each2(function(){0===this.indexOf("select2-")&&f.push(this)})),e=a.trim(c.attr("class")),e&&(e=""+e,a(e.split(/\s+/)).each2(function(){0!==this.indexOf("select2-")&&(g=d(this),g&&f.push(g))})),b.attr("class",f.join(" "))}function E(a,b,c,d){var e=o(a.toUpperCase()).indexOf(o(b.toUpperCase())),f=b.length;return 0>e?(c.push(d(a)),void 0):(c.push(d(a.substring(0,e))),c.push(""),c.push(d(a.substring(e,e+f))),c.push(""),c.push(d(a.substring(e+f,a.length))),void 0)}function F(a){var b={"\\":"\","&":"&","<":"<",">":">",'"':""","'":"'","/":"/"};return String(a).replace(/[&<>"'\/\\]/g,function(a){return b[a]})}function G(c){var d,e=null,f=c.quietMillis||100,g=c.url,h=this;return function(i){window.clearTimeout(d),d=window.setTimeout(function(){var d=c.data,f=g,j=c.transport||a.fn.select2.ajaxDefaults.transport,k={type:c.type||"GET",cache:c.cache||!1,jsonpCallback:c.jsonpCallback||b,dataType:c.dataType||"json"},l=a.extend({},a.fn.select2.ajaxDefaults.params,k);d=d?d.call(h,i.term,i.page,i.context):null,f="function"==typeof f?f.call(h,i.term,i.page,i.context):f,e&&"function"==typeof e.abort&&e.abort(),c.params&&(a.isFunction(c.params)?a.extend(l,c.params.call(h)):a.extend(l,c.params)),a.extend(l,{url:f,dataType:c.dataType,data:d,success:function(a){var b=c.results(a,i.page,i);i.callback(b)},error:function(a,b,c){var d={hasError:!0,jqXHR:a,textStatus:b,errorThrown:c};i.callback(d)}}),e=j.call(h,l)},f)}}function H(b){var d,e,c=b,f=function(a){return""+a.text};a.isArray(c)&&(e=c,c={results:e}),a.isFunction(c)===!1&&(e=c,c=function(){return e});var g=c();return g.text&&(f=g.text,a.isFunction(f)||(d=g.text,f=function(a){return a[d]})),function(b){var g,d=b.term,e={results:[]};return""===d?(b.callback(c()),void 0):(g=function(c,e){var h,i;if(c=c[0],c.children){h={};for(i in c)c.hasOwnProperty(i)&&(h[i]=c[i]);h.children=[],a(c.children).each2(function(a,b){g(b,h.children)}),(h.children.length||b.matcher(d,f(h),c))&&e.push(h)}else b.matcher(d,f(c),c)&&e.push(c)},a(c().results).each2(function(a,b){g(b,e.results)}),b.callback(e),void 0)}}function I(c){var d=a.isFunction(c);return function(e){var f=e.term,g={results:[]},h=d?c(e):c;a.isArray(h)&&(a(h).each(function(){var a=this.text!==b,c=a?this.text:this;(""===f||e.matcher(f,c))&&g.results.push(a?this:{id:this,text:this})}),e.callback(g))}}function J(b,c){if(a.isFunction(b))return!0;if(!b)return!1;if("string"==typeof b)return!0;throw new Error(c+" must be a string, function, or falsy value")}function K(b,c){if(a.isFunction(b)){var d=Array.prototype.slice.call(arguments,2);return b.apply(c,d)}return b}function L(b){var c=0;return a.each(b,function(a,b){b.children?c+=L(b.children):c++}),c}function M(a,c,d,e){var h,i,j,k,l,f=a,g=!1;if(!e.createSearchChoice||!e.tokenSeparators||e.tokenSeparators.length<1)return b;for(;;){for(i=-1,j=0,k=e.tokenSeparators.length;k>j&&(l=e.tokenSeparators[j],i=a.indexOf(l),!(i>=0));j++);if(0>i)break;if(h=a.substring(0,i),a=a.substring(i+l.length),h.length>0&&(h=e.createSearchChoice.call(this,h,c),h!==b&&null!==h&&e.id(h)!==b&&null!==e.id(h))){for(g=!1,j=0,k=c.length;k>j;j++)if(r(e.id(h),e.id(c[j]))){g=!0;break}g||d(h)}}return f!==a?a:void 0}function N(){var b=this;a.each(arguments,function(a,c){b[c].remove(),b[c]=null})}function O(b,c){var d=function(){};return d.prototype=new b,d.prototype.constructor=d,d.prototype.parent=b.prototype,d.prototype=a.extend(d.prototype,c),d}if(window.Select2===b){var c,d,e,f,g,i,j,h={x:0,y:0},k={TAB:9,ENTER:13,ESC:27,SPACE:32,LEFT:37,UP:38,RIGHT:39,DOWN:40,SHIFT:16,CTRL:17,ALT:18,PAGE_UP:33,PAGE_DOWN:34,HOME:36,END:35,BACKSPACE:8,DELETE:46,isArrow:function(a){switch(a=a.which?a.which:a){case k.LEFT:case k.RIGHT:case k.UP:case k.DOWN:return!0}return!1},isControl:function(a){var b=a.which;switch(b){case k.SHIFT:case k.CTRL:case k.ALT:return!0}return a.metaKey?!0:!1},isFunctionKey:function(a){return a=a.which?a.which:a,a>=112&&123>=a}},l="",m={"\u24b6":"A","\uff21":"A","\xc0":"A","\xc1":"A","\xc2":"A","\u1ea6":"A","\u1ea4":"A","\u1eaa":"A","\u1ea8":"A","\xc3":"A","\u0100":"A","\u0102":"A","\u1eb0":"A","\u1eae":"A","\u1eb4":"A","\u1eb2":"A","\u0226":"A","\u01e0":"A","\xc4":"A","\u01de":"A","\u1ea2":"A","\xc5":"A","\u01fa":"A","\u01cd":"A","\u0200":"A","\u0202":"A","\u1ea0":"A","\u1eac":"A","\u1eb6":"A","\u1e00":"A","\u0104":"A","\u023a":"A","\u2c6f":"A","\ua732":"AA","\xc6":"AE","\u01fc":"AE","\u01e2":"AE","\ua734":"AO","\ua736":"AU","\ua738":"AV","\ua73a":"AV","\ua73c":"AY","\u24b7":"B","\uff22":"B","\u1e02":"B","\u1e04":"B","\u1e06":"B","\u0243":"B","\u0182":"B","\u0181":"B","\u24b8":"C","\uff23":"C","\u0106":"C","\u0108":"C","\u010a":"C","\u010c":"C","\xc7":"C","\u1e08":"C","\u0187":"C","\u023b":"C","\ua73e":"C","\u24b9":"D","\uff24":"D","\u1e0a":"D","\u010e":"D","\u1e0c":"D","\u1e10":"D","\u1e12":"D","\u1e0e":"D","\u0110":"D","\u018b":"D","\u018a":"D","\u0189":"D","\ua779":"D","\u01f1":"DZ","\u01c4":"DZ","\u01f2":"Dz","\u01c5":"Dz","\u24ba":"E","\uff25":"E","\xc8":"E","\xc9":"E","\xca":"E","\u1ec0":"E","\u1ebe":"E","\u1ec4":"E","\u1ec2":"E","\u1ebc":"E","\u0112":"E","\u1e14":"E","\u1e16":"E","\u0114":"E","\u0116":"E","\xcb":"E","\u1eba":"E","\u011a":"E","\u0204":"E","\u0206":"E","\u1eb8":"E","\u1ec6":"E","\u0228":"E","\u1e1c":"E","\u0118":"E","\u1e18":"E","\u1e1a":"E","\u0190":"E","\u018e":"E","\u24bb":"F","\uff26":"F","\u1e1e":"F","\u0191":"F","\ua77b":"F","\u24bc":"G","\uff27":"G","\u01f4":"G","\u011c":"G","\u1e20":"G","\u011e":"G","\u0120":"G","\u01e6":"G","\u0122":"G","\u01e4":"G","\u0193":"G","\ua7a0":"G","\ua77d":"G","\ua77e":"G","\u24bd":"H","\uff28":"H","\u0124":"H","\u1e22":"H","\u1e26":"H","\u021e":"H","\u1e24":"H","\u1e28":"H","\u1e2a":"H","\u0126":"H","\u2c67":"H","\u2c75":"H","\ua78d":"H","\u24be":"I","\uff29":"I","\xcc":"I","\xcd":"I","\xce":"I","\u0128":"I","\u012a":"I","\u012c":"I","\u0130":"I","\xcf":"I","\u1e2e":"I","\u1ec8":"I","\u01cf":"I","\u0208":"I","\u020a":"I","\u1eca":"I","\u012e":"I","\u1e2c":"I","\u0197":"I","\u24bf":"J","\uff2a":"J","\u0134":"J","\u0248":"J","\u24c0":"K","\uff2b":"K","\u1e30":"K","\u01e8":"K","\u1e32":"K","\u0136":"K","\u1e34":"K","\u0198":"K","\u2c69":"K","\ua740":"K","\ua742":"K","\ua744":"K","\ua7a2":"K","\u24c1":"L","\uff2c":"L","\u013f":"L","\u0139":"L","\u013d":"L","\u1e36":"L","\u1e38":"L","\u013b":"L","\u1e3c":"L","\u1e3a":"L","\u0141":"L","\u023d":"L","\u2c62":"L","\u2c60":"L","\ua748":"L","\ua746":"L","\ua780":"L","\u01c7":"LJ","\u01c8":"Lj","\u24c2":"M","\uff2d":"M","\u1e3e":"M","\u1e40":"M","\u1e42":"M","\u2c6e":"M","\u019c":"M","\u24c3":"N","\uff2e":"N","\u01f8":"N","\u0143":"N","\xd1":"N","\u1e44":"N","\u0147":"N","\u1e46":"N","\u0145":"N","\u1e4a":"N","\u1e48":"N","\u0220":"N","\u019d":"N","\ua790":"N","\ua7a4":"N","\u01ca":"NJ","\u01cb":"Nj","\u24c4":"O","\uff2f":"O","\xd2":"O","\xd3":"O","\xd4":"O","\u1ed2":"O","\u1ed0":"O","\u1ed6":"O","\u1ed4":"O","\xd5":"O","\u1e4c":"O","\u022c":"O","\u1e4e":"O","\u014c":"O","\u1e50":"O","\u1e52":"O","\u014e":"O","\u022e":"O","\u0230":"O","\xd6":"O","\u022a":"O","\u1ece":"O","\u0150":"O","\u01d1":"O","\u020c":"O","\u020e":"O","\u01a0":"O","\u1edc":"O","\u1eda":"O","\u1ee0":"O","\u1ede":"O","\u1ee2":"O","\u1ecc":"O","\u1ed8":"O","\u01ea":"O","\u01ec":"O","\xd8":"O","\u01fe":"O","\u0186":"O","\u019f":"O","\ua74a":"O","\ua74c":"O","\u01a2":"OI","\ua74e":"OO","\u0222":"OU","\u24c5":"P","\uff30":"P","\u1e54":"P","\u1e56":"P","\u01a4":"P","\u2c63":"P","\ua750":"P","\ua752":"P","\ua754":"P","\u24c6":"Q","\uff31":"Q","\ua756":"Q","\ua758":"Q","\u024a":"Q","\u24c7":"R","\uff32":"R","\u0154":"R","\u1e58":"R","\u0158":"R","\u0210":"R","\u0212":"R","\u1e5a":"R","\u1e5c":"R","\u0156":"R","\u1e5e":"R","\u024c":"R","\u2c64":"R","\ua75a":"R","\ua7a6":"R","\ua782":"R","\u24c8":"S","\uff33":"S","\u1e9e":"S","\u015a":"S","\u1e64":"S","\u015c":"S","\u1e60":"S","\u0160":"S","\u1e66":"S","\u1e62":"S","\u1e68":"S","\u0218":"S","\u015e":"S","\u2c7e":"S","\ua7a8":"S","\ua784":"S","\u24c9":"T","\uff34":"T","\u1e6a":"T","\u0164":"T","\u1e6c":"T","\u021a":"T","\u0162":"T","\u1e70":"T","\u1e6e":"T","\u0166":"T","\u01ac":"T","\u01ae":"T","\u023e":"T","\ua786":"T","\ua728":"TZ","\u24ca":"U","\uff35":"U","\xd9":"U","\xda":"U","\xdb":"U","\u0168":"U","\u1e78":"U","\u016a":"U","\u1e7a":"U","\u016c":"U","\xdc":"U","\u01db":"U","\u01d7":"U","\u01d5":"U","\u01d9":"U","\u1ee6":"U","\u016e":"U","\u0170":"U","\u01d3":"U","\u0214":"U","\u0216":"U","\u01af":"U","\u1eea":"U","\u1ee8":"U","\u1eee":"U","\u1eec":"U","\u1ef0":"U","\u1ee4":"U","\u1e72":"U","\u0172":"U","\u1e76":"U","\u1e74":"U","\u0244":"U","\u24cb":"V","\uff36":"V","\u1e7c":"V","\u1e7e":"V","\u01b2":"V","\ua75e":"V","\u0245":"V","\ua760":"VY","\u24cc":"W","\uff37":"W","\u1e80":"W","\u1e82":"W","\u0174":"W","\u1e86":"W","\u1e84":"W","\u1e88":"W","\u2c72":"W","\u24cd":"X","\uff38":"X","\u1e8a":"X","\u1e8c":"X","\u24ce":"Y","\uff39":"Y","\u1ef2":"Y","\xdd":"Y","\u0176":"Y","\u1ef8":"Y","\u0232":"Y","\u1e8e":"Y","\u0178":"Y","\u1ef6":"Y","\u1ef4":"Y","\u01b3":"Y","\u024e":"Y","\u1efe":"Y","\u24cf":"Z","\uff3a":"Z","\u0179":"Z","\u1e90":"Z","\u017b":"Z","\u017d":"Z","\u1e92":"Z","\u1e94":"Z","\u01b5":"Z","\u0224":"Z","\u2c7f":"Z","\u2c6b":"Z","\ua762":"Z","\u24d0":"a","\uff41":"a","\u1e9a":"a","\xe0":"a","\xe1":"a","\xe2":"a","\u1ea7":"a","\u1ea5":"a","\u1eab":"a","\u1ea9":"a","\xe3":"a","\u0101":"a","\u0103":"a","\u1eb1":"a","\u1eaf":"a","\u1eb5":"a","\u1eb3":"a","\u0227":"a","\u01e1":"a","\xe4":"a","\u01df":"a","\u1ea3":"a","\xe5":"a","\u01fb":"a","\u01ce":"a","\u0201":"a","\u0203":"a","\u1ea1":"a","\u1ead":"a","\u1eb7":"a","\u1e01":"a","\u0105":"a","\u2c65":"a","\u0250":"a","\ua733":"aa","\xe6":"ae","\u01fd":"ae","\u01e3":"ae","\ua735":"ao","\ua737":"au","\ua739":"av","\ua73b":"av","\ua73d":"ay","\u24d1":"b","\uff42":"b","\u1e03":"b","\u1e05":"b","\u1e07":"b","\u0180":"b","\u0183":"b","\u0253":"b","\u24d2":"c","\uff43":"c","\u0107":"c","\u0109":"c","\u010b":"c","\u010d":"c","\xe7":"c","\u1e09":"c","\u0188":"c","\u023c":"c","\ua73f":"c","\u2184":"c","\u24d3":"d","\uff44":"d","\u1e0b":"d","\u010f":"d","\u1e0d":"d","\u1e11":"d","\u1e13":"d","\u1e0f":"d","\u0111":"d","\u018c":"d","\u0256":"d","\u0257":"d","\ua77a":"d","\u01f3":"dz","\u01c6":"dz","\u24d4":"e","\uff45":"e","\xe8":"e","\xe9":"e","\xea":"e","\u1ec1":"e","\u1ebf":"e","\u1ec5":"e","\u1ec3":"e","\u1ebd":"e","\u0113":"e","\u1e15":"e","\u1e17":"e","\u0115":"e","\u0117":"e","\xeb":"e","\u1ebb":"e","\u011b":"e","\u0205":"e","\u0207":"e","\u1eb9":"e","\u1ec7":"e","\u0229":"e","\u1e1d":"e","\u0119":"e","\u1e19":"e","\u1e1b":"e","\u0247":"e","\u025b":"e","\u01dd":"e","\u24d5":"f","\uff46":"f","\u1e1f":"f","\u0192":"f","\ua77c":"f","\u24d6":"g","\uff47":"g","\u01f5":"g","\u011d":"g","\u1e21":"g","\u011f":"g","\u0121":"g","\u01e7":"g","\u0123":"g","\u01e5":"g","\u0260":"g","\ua7a1":"g","\u1d79":"g","\ua77f":"g","\u24d7":"h","\uff48":"h","\u0125":"h","\u1e23":"h","\u1e27":"h","\u021f":"h","\u1e25":"h","\u1e29":"h","\u1e2b":"h","\u1e96":"h","\u0127":"h","\u2c68":"h","\u2c76":"h","\u0265":"h","\u0195":"hv","\u24d8":"i","\uff49":"i","\xec":"i","\xed":"i","\xee":"i","\u0129":"i","\u012b":"i","\u012d":"i","\xef":"i","\u1e2f":"i","\u1ec9":"i","\u01d0":"i","\u0209":"i","\u020b":"i","\u1ecb":"i","\u012f":"i","\u1e2d":"i","\u0268":"i","\u0131":"i","\u24d9":"j","\uff4a":"j","\u0135":"j","\u01f0":"j","\u0249":"j","\u24da":"k","\uff4b":"k","\u1e31":"k","\u01e9":"k","\u1e33":"k","\u0137":"k","\u1e35":"k","\u0199":"k","\u2c6a":"k","\ua741":"k","\ua743":"k","\ua745":"k","\ua7a3":"k","\u24db":"l","\uff4c":"l","\u0140":"l","\u013a":"l","\u013e":"l","\u1e37":"l","\u1e39":"l","\u013c":"l","\u1e3d":"l","\u1e3b":"l","\u017f":"l","\u0142":"l","\u019a":"l","\u026b":"l","\u2c61":"l","\ua749":"l","\ua781":"l","\ua747":"l","\u01c9":"lj","\u24dc":"m","\uff4d":"m","\u1e3f":"m","\u1e41":"m","\u1e43":"m","\u0271":"m","\u026f":"m","\u24dd":"n","\uff4e":"n","\u01f9":"n","\u0144":"n","\xf1":"n","\u1e45":"n","\u0148":"n","\u1e47":"n","\u0146":"n","\u1e4b":"n","\u1e49":"n","\u019e":"n","\u0272":"n","\u0149":"n","\ua791":"n","\ua7a5":"n","\u01cc":"nj","\u24de":"o","\uff4f":"o","\xf2":"o","\xf3":"o","\xf4":"o","\u1ed3":"o","\u1ed1":"o","\u1ed7":"o","\u1ed5":"o","\xf5":"o","\u1e4d":"o","\u022d":"o","\u1e4f":"o","\u014d":"o","\u1e51":"o","\u1e53":"o","\u014f":"o","\u022f":"o","\u0231":"o","\xf6":"o","\u022b":"o","\u1ecf":"o","\u0151":"o","\u01d2":"o","\u020d":"o","\u020f":"o","\u01a1":"o","\u1edd":"o","\u1edb":"o","\u1ee1":"o","\u1edf":"o","\u1ee3":"o","\u1ecd":"o","\u1ed9":"o","\u01eb":"o","\u01ed":"o","\xf8":"o","\u01ff":"o","\u0254":"o","\ua74b":"o","\ua74d":"o","\u0275":"o","\u01a3":"oi","\u0223":"ou","\ua74f":"oo","\u24df":"p","\uff50":"p","\u1e55":"p","\u1e57":"p","\u01a5":"p","\u1d7d":"p","\ua751":"p","\ua753":"p","\ua755":"p","\u24e0":"q","\uff51":"q","\u024b":"q","\ua757":"q","\ua759":"q","\u24e1":"r","\uff52":"r","\u0155":"r","\u1e59":"r","\u0159":"r","\u0211":"r","\u0213":"r","\u1e5b":"r","\u1e5d":"r","\u0157":"r","\u1e5f":"r","\u024d":"r","\u027d":"r","\ua75b":"r","\ua7a7":"r","\ua783":"r","\u24e2":"s","\uff53":"s","\xdf":"s","\u015b":"s","\u1e65":"s","\u015d":"s","\u1e61":"s","\u0161":"s","\u1e67":"s","\u1e63":"s","\u1e69":"s","\u0219":"s","\u015f":"s","\u023f":"s","\ua7a9":"s","\ua785":"s","\u1e9b":"s","\u24e3":"t","\uff54":"t","\u1e6b":"t","\u1e97":"t","\u0165":"t","\u1e6d":"t","\u021b":"t","\u0163":"t","\u1e71":"t","\u1e6f":"t","\u0167":"t","\u01ad":"t","\u0288":"t","\u2c66":"t","\ua787":"t","\ua729":"tz","\u24e4":"u","\uff55":"u","\xf9":"u","\xfa":"u","\xfb":"u","\u0169":"u","\u1e79":"u","\u016b":"u","\u1e7b":"u","\u016d":"u","\xfc":"u","\u01dc":"u","\u01d8":"u","\u01d6":"u","\u01da":"u","\u1ee7":"u","\u016f":"u","\u0171":"u","\u01d4":"u","\u0215":"u","\u0217":"u","\u01b0":"u","\u1eeb":"u","\u1ee9":"u","\u1eef":"u","\u1eed":"u","\u1ef1":"u","\u1ee5":"u","\u1e73":"u","\u0173":"u","\u1e77":"u","\u1e75":"u","\u0289":"u","\u24e5":"v","\uff56":"v","\u1e7d":"v","\u1e7f":"v","\u028b":"v","\ua75f":"v","\u028c":"v","\ua761":"vy","\u24e6":"w","\uff57":"w","\u1e81":"w","\u1e83":"w","\u0175":"w","\u1e87":"w","\u1e85":"w","\u1e98":"w","\u1e89":"w","\u2c73":"w","\u24e7":"x","\uff58":"x","\u1e8b":"x","\u1e8d":"x","\u24e8":"y","\uff59":"y","\u1ef3":"y","\xfd":"y","\u0177":"y","\u1ef9":"y","\u0233":"y","\u1e8f":"y","\xff":"y","\u1ef7":"y","\u1e99":"y","\u1ef5":"y","\u01b4":"y","\u024f":"y","\u1eff":"y","\u24e9":"z","\uff5a":"z","\u017a":"z","\u1e91":"z","\u017c":"z","\u017e":"z","\u1e93":"z","\u1e95":"z","\u01b6":"z","\u0225":"z","\u0240":"z","\u2c6c":"z","\ua763":"z","\u0386":"\u0391","\u0388":"\u0395","\u0389":"\u0397","\u038a":"\u0399","\u03aa":"\u0399","\u038c":"\u039f","\u038e":"\u03a5","\u03ab":"\u03a5","\u038f":"\u03a9","\u03ac":"\u03b1","\u03ad":"\u03b5","\u03ae":"\u03b7","\u03af":"\u03b9","\u03ca":"\u03b9","\u0390":"\u03b9","\u03cc":"\u03bf","\u03cd":"\u03c5","\u03cb":"\u03c5","\u03b0":"\u03c5","\u03c9":"\u03c9","\u03c2":"\u03c3"};i=a(document),f=function(){var a=1;return function(){return a++}}(),c=O(Object,{bind:function(a){var b=this;return function(){a.apply(b,arguments)}},init:function(c){var d,e,g=".select2-results";this.opts=c=this.prepareOpts(c),this.id=c.id,c.element.data("select2")!==b&&null!==c.element.data("select2")&&c.element.data("select2").destroy(),this.container=this.createContainer(),this.liveRegion=a(".select2-hidden-accessible"),0==this.liveRegion.length&&(this.liveRegion=a("",{role:"status","aria-live":"polite"}).addClass("select2-hidden-accessible").appendTo(document.body)),this.containerId="s2id_"+(c.element.attr("id")||"autogen"+f()),this.containerEventName=this.containerId.replace(/([.])/g,"_").replace(/([;&,\-\.\+\*\~':"\!\^#$%@\[\]\(\)=>\|])/g,"\\$1"),this.container.attr("id",this.containerId),this.container.attr("title",c.element.attr("title")),this.body=a(document.body),D(this.container,this.opts.element,this.opts.adaptContainerCssClass),this.container.attr("style",c.element.attr("style")),this.container.css(K(c.containerCss,this.opts.element)),this.container.addClass(K(c.containerCssClass,this.opts.element)),this.elementTabIndex=this.opts.element.attr("tabindex"),this.opts.element.data("select2",this).attr("tabindex","-1").before(this.container).on("click.select2",A),this.container.data("select2",this),this.dropdown=this.container.find(".select2-drop"),D(this.dropdown,this.opts.element,this.opts.adaptDropdownCssClass),this.dropdown.addClass(K(c.dropdownCssClass,this.opts.element)),this.dropdown.data("select2",this),this.dropdown.on("click",A),this.results=d=this.container.find(g),this.search=e=this.container.find("input.select2-input"),this.queryCount=0,this.resultsPage=0,this.context=null,this.initContainer(),this.container.on("click",A),v(this.results),this.dropdown.on("mousemove-filtered",g,this.bind(this.highlightUnderEvent)),this.dropdown.on("touchstart touchmove touchend",g,this.bind(function(a){this._touchEvent=!0,this.highlightUnderEvent(a)})),this.dropdown.on("touchmove",g,this.bind(this.touchMoved)),this.dropdown.on("touchstart touchend",g,this.bind(this.clearTouchMoved)),this.dropdown.on("click",this.bind(function(){this._touchEvent&&(this._touchEvent=!1,this.selectHighlighted())})),x(80,this.results),this.dropdown.on("scroll-debounced",g,this.bind(this.loadMoreIfNeeded)),a(this.container).on("change",".select2-input",function(a){a.stopPropagation()}),a(this.dropdown).on("change",".select2-input",function(a){a.stopPropagation()}),a.fn.mousewheel&&d.mousewheel(function(a,b,c,e){var f=d.scrollTop();e>0&&0>=f-e?(d.scrollTop(0),A(a)):0>e&&d.get(0).scrollHeight-d.scrollTop()+e<=d.height()&&(d.scrollTop(d.get(0).scrollHeight-d.height()),A(a))}),u(e),e.on("keyup-change input paste",this.bind(this.updateResults)),e.on("focus",function(){e.addClass("select2-focused")}),e.on("blur",function(){e.removeClass("select2-focused")}),this.dropdown.on("mouseup",g,this.bind(function(b){a(b.target).closest(".select2-result-selectable").length>0&&(this.highlightUnderEvent(b),this.selectHighlighted(b))})),this.dropdown.on("click mouseup mousedown touchstart touchend focusin",function(a){a.stopPropagation()}),this.nextSearchTerm=b,a.isFunction(this.opts.initSelection)&&(this.initSelection(),this.monitorSource()),null!==c.maximumInputLength&&this.search.attr("maxlength",c.maximumInputLength);var h=c.element.prop("disabled");h===b&&(h=!1),this.enable(!h);var i=c.element.prop("readonly");i===b&&(i=!1),this.readonly(i),j=j||q(),this.autofocus=c.element.prop("autofocus"),c.element.prop("autofocus",!1),this.autofocus&&this.focus(),this.search.attr("placeholder",c.searchInputPlaceholder)},destroy:function(){var a=this.opts.element,c=a.data("select2"),d=this;this.close(),a.length&&a[0].detachEvent&&d._sync&&a.each(function(){d._sync&&this.detachEvent("onpropertychange",d._sync)}),this.propertyObserver&&(this.propertyObserver.disconnect(),this.propertyObserver=null),this._sync=null,c!==b&&(c.container.remove(),c.liveRegion.remove(),c.dropdown.remove(),a.show().removeData("select2").off(".select2").prop("autofocus",this.autofocus||!1),this.elementTabIndex?a.attr({tabindex:this.elementTabIndex}):a.removeAttr("tabindex"),a.show()),N.call(this,"container","liveRegion","dropdown","results","search")},optionToData:function(a){return a.is("option")?{id:a.prop("value"),text:a.text(),element:a.get(),css:a.attr("class"),disabled:a.prop("disabled"),locked:r(a.attr("locked"),"locked")||r(a.data("locked"),!0)}:a.is("optgroup")?{text:a.attr("label"),children:[],element:a.get(),css:a.attr("class")}:void 0},prepareOpts:function(c){var d,e,g,h,i=this;if(d=c.element,"select"===d.get(0).tagName.toLowerCase()&&(this.select=e=c.element),e&&a.each(["id","multiple","ajax","query","createSearchChoice","initSelection","data","tags"],function(){if(this in c)throw new Error("Option '"+this+"' is not allowed for Select2 when attached to a ');return e.attr("dir",this.options.get("dir")),this.$container=e,this.$container[0].classList.add("select2-container--"+this.options.get("theme")),o.StoreData(e[0],"element",this.$element),e},r}),u.define("select2/dropdown/attachContainer",[],function(){function e(e,t,n){e.call(this,t,n)}return e.prototype.position=function(e,t,n){n.find(".dropdown-wrapper").append(t),t[0].classList.add("select2-dropdown--below"),n[0].classList.add("select2-container--below")},e}),u.define("select2/dropdown/stopPropagation",[],function(){function e(){}return e.prototype.bind=function(e,t,n){e.call(this,t,n);this.$dropdown.on(["blur","change","click","dblclick","focus","focusin","focusout","input","keydown","keyup","keypress","mousedown","mouseenter","mouseleave","mousemove","mouseover","mouseup","search","touchend","touchstart"].join(" "),function(e){e.stopPropagation()})},e}),u.define("select2/selection/stopPropagation",[],function(){function e(){}return e.prototype.bind=function(e,t,n){e.call(this,t,n);this.$selection.on(["blur","change","click","dblclick","focus","focusin","focusout","input","keydown","keyup","keypress","mousedown","mouseenter","mouseleave","mousemove","mouseover","mouseup","search","touchend","touchstart"].join(" "),function(e){e.stopPropagation()})},e}),a=function(u){var d,p,e=["wheel","mousewheel","DOMMouseScroll","MozMousePixelScroll"],t="onwheel"in document||9<=document.documentMode?["wheel"]:["mousewheel","DomMouseScroll","MozMousePixelScroll"],h=Array.prototype.slice;if(u.event.fixHooks)for(var n=e.length;n;)u.event.fixHooks[e[--n]]=u.event.mouseHooks;var f=u.event.special.mousewheel={version:"3.1.12",setup:function(){if(this.addEventListener)for(var e=t.length;e;)this.addEventListener(t[--e],s,!1);else this.onmousewheel=s;u.data(this,"mousewheel-line-height",f.getLineHeight(this)),u.data(this,"mousewheel-page-height",f.getPageHeight(this))},teardown:function(){if(this.removeEventListener)for(var e=t.length;e;)this.removeEventListener(t[--e],s,!1);else this.onmousewheel=null;u.removeData(this,"mousewheel-line-height"),u.removeData(this,"mousewheel-page-height")},getLineHeight:function(e){var t=u(e),e=t["offsetParent"in u.fn?"offsetParent":"parent"]();return e.length||(e=u("body")),parseInt(e.css("fontSize"),10)||parseInt(t.css("fontSize"),10)||16},getPageHeight:function(e){return u(e).height()},settings:{adjustOldDeltas:!0,normalizeOffset:!0}};function s(e){var t,n=e||window.event,s=h.call(arguments,1),i=0,o=0,r=0,a=0,l=0,c=0;if(e=u.event.fix(n),e.type="mousewheel","detail"in n&&(r=-1*n.detail),"wheelDelta"in n&&(r=n.wheelDelta),"wheelDeltaY"in n&&(r=n.wheelDeltaY),"wheelDeltaX"in n&&(o=-1*n.wheelDeltaX),"axis"in n&&n.axis===n.HORIZONTAL_AXIS&&(o=-1*r,r=0),i=0===r?o:r,"deltaY"in n&&(i=r=-1*n.deltaY),"deltaX"in n&&(o=n.deltaX,0===r&&(i=-1*o)),0!==r||0!==o)return 1===n.deltaMode?(i*=t=u.data(this,"mousewheel-line-height"),r*=t,o*=t):2===n.deltaMode&&(i*=t=u.data(this,"mousewheel-page-height"),r*=t,o*=t),a=Math.max(Math.abs(r),Math.abs(o)),(!p||a 0) {
name.splice(i - 1, 2);
i -= 2;
}
}
}
//end trimDots
name = name.join('/');
}
//Apply map config if available.
if ((baseParts || starMap) && map) {
nameParts = name.split('/');
for (i = nameParts.length; i > 0; i -= 1) {
nameSegment = nameParts.slice(0, i).join("/");
if (baseParts) {
//Find the longest baseName segment match in the config.
//So, do joins on the biggest to smallest lengths of baseParts.
for (j = baseParts.length; j > 0; j -= 1) {
mapValue = map[baseParts.slice(0, j).join('/')];
//baseName segment has config, find if it has one for
//this name.
if (mapValue) {
mapValue = mapValue[nameSegment];
if (mapValue) {
//Match, update name to the new value.
foundMap = mapValue;
foundI = i;
break;
}
}
}
}
if (foundMap) {
break;
}
//Check for a star map match, but just hold on to it,
//if there is a shorter segment match later in a matching
//config, then favor over this star map.
if (!foundStarMap && starMap && starMap[nameSegment]) {
foundStarMap = starMap[nameSegment];
starI = i;
}
}
if (!foundMap && foundStarMap) {
foundMap = foundStarMap;
foundI = starI;
}
if (foundMap) {
nameParts.splice(0, foundI, foundMap);
name = nameParts.join('/');
}
}
return name;
}
function makeRequire(relName, forceSync) {
return function () {
//A version of a require function that passes a moduleName
//value for items that may need to
//look up paths relative to the moduleName
var args = aps.call(arguments, 0);
//If first arg is not require('string'), and there is only
//one arg, it is the array form without a callback. Insert
//a null so that the following concat is correct.
if (typeof args[0] !== 'string' && args.length === 1) {
args.push(null);
}
return req.apply(undef, args.concat([relName, forceSync]));
};
}
function makeNormalize(relName) {
return function (name) {
return normalize(name, relName);
};
}
function makeLoad(depName) {
return function (value) {
defined[depName] = value;
};
}
function callDep(name) {
if (hasProp(waiting, name)) {
var args = waiting[name];
delete waiting[name];
defining[name] = true;
main.apply(undef, args);
}
if (!hasProp(defined, name) && !hasProp(defining, name)) {
throw new Error('No ' + name);
}
return defined[name];
}
//Turns a plugin!resource to [plugin, resource]
//with the plugin being undefined if the name
//did not have a plugin prefix.
function splitPrefix(name) {
var prefix,
index = name ? name.indexOf('!') : -1;
if (index > -1) {
prefix = name.substring(0, index);
name = name.substring(index + 1, name.length);
}
return [prefix, name];
}
//Creates a parts array for a relName where first part is plugin ID,
//second part is resource ID. Assumes relName has already been normalized.
function makeRelParts(relName) {
return relName ? splitPrefix(relName) : [];
}
/**
* Makes a name map, normalizing the name, and using a plugin
* for normalization if necessary. Grabs a ref to plugin
* too, as an optimization.
*/
makeMap = function (name, relParts) {
var plugin,
parts = splitPrefix(name),
prefix = parts[0],
relResourceName = relParts[1];
name = parts[1];
if (prefix) {
prefix = normalize(prefix, relResourceName);
plugin = callDep(prefix);
}
//Normalize according
if (prefix) {
if (plugin && plugin.normalize) {
name = plugin.normalize(name, makeNormalize(relResourceName));
} else {
name = normalize(name, relResourceName);
}
} else {
name = normalize(name, relResourceName);
parts = splitPrefix(name);
prefix = parts[0];
name = parts[1];
if (prefix) {
plugin = callDep(prefix);
}
}
//Using ridiculous property names for space reasons
return {
f: prefix ? prefix + '!' + name : name, //fullName
n: name,
pr: prefix,
p: plugin
};
};
function makeConfig(name) {
return function () {
return (config && config.config && config.config[name]) || {};
};
}
handlers = {
require: function (name) {
return makeRequire(name);
},
exports: function (name) {
var e = defined[name];
if (typeof e !== 'undefined') {
return e;
} else {
return (defined[name] = {});
}
},
module: function (name) {
return {
id: name,
uri: '',
exports: defined[name],
config: makeConfig(name)
};
}
};
main = function (name, deps, callback, relName) {
var cjsModule, depName, ret, map, i, relParts,
args = [],
callbackType = typeof callback,
usingExports;
//Use name if no relName
relName = relName || name;
relParts = makeRelParts(relName);
//Call the callback to define the module, if necessary.
if (callbackType === 'undefined' || callbackType === 'function') {
//Pull out the defined dependencies and pass the ordered
//values to the callback.
//Default to [require, exports, module] if no deps
deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps;
for (i = 0; i < deps.length; i += 1) {
map = makeMap(deps[i], relParts);
depName = map.f;
//Fast path CommonJS standard dependencies.
if (depName === "require") {
args[i] = handlers.require(name);
} else if (depName === "exports") {
//CommonJS module spec 1.1
args[i] = handlers.exports(name);
usingExports = true;
} else if (depName === "module") {
//CommonJS module spec 1.1
cjsModule = args[i] = handlers.module(name);
} else if (hasProp(defined, depName) ||
hasProp(waiting, depName) ||
hasProp(defining, depName)) {
args[i] = callDep(depName);
} else if (map.p) {
map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {});
args[i] = defined[depName];
} else {
throw new Error(name + ' missing ' + depName);
}
}
ret = callback ? callback.apply(defined[name], args) : undefined;
if (name) {
//If setting exports via "module" is in play,
//favor that over return value and exports. After that,
//favor a non-undefined return value over exports use.
if (cjsModule && cjsModule.exports !== undef &&
cjsModule.exports !== defined[name]) {
defined[name] = cjsModule.exports;
} else if (ret !== undef || !usingExports) {
//Use the return value from the function.
defined[name] = ret;
}
}
} else if (name) {
//May just be an object definition for the module. Only
//worry about defining if have a module name.
defined[name] = callback;
}
};
requirejs = require = req = function (deps, callback, relName, forceSync, alt) {
if (typeof deps === "string") {
if (handlers[deps]) {
//callback in this case is really relName
return handlers[deps](callback);
}
//Just return the module wanted. In this scenario, the
//deps arg is the module name, and second arg (if passed)
//is just the relName.
//Normalize module name, if it contains . or ..
return callDep(makeMap(deps, makeRelParts(callback)).f);
} else if (!deps.splice) {
//deps is a config object, not an array.
config = deps;
if (config.deps) {
req(config.deps, config.callback);
}
if (!callback) {
return;
}
if (callback.splice) {
//callback is an array, which means it is a dependency list.
//Adjust args if there are dependencies
deps = callback;
callback = relName;
relName = null;
} else {
deps = undef;
}
}
//Support require(['a'])
callback = callback || function () {};
//If relName is a function, it is an errback handler,
//so remove it.
if (typeof relName === 'function') {
relName = forceSync;
forceSync = alt;
}
//Simulate async callback;
if (forceSync) {
main(undef, deps, callback, relName);
} else {
//Using a non-zero value because of concern for what old browsers
//do, and latest browsers "upgrade" to 4 if lower value is used:
//http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout:
//If want a value immediately, use require('id') instead -- something
//that works in almond on the global level, but not guaranteed and
//unlikely to work in other AMD implementations.
setTimeout(function () {
main(undef, deps, callback, relName);
}, 4);
}
return req;
};
/**
* Just drops the config on the floor, but returns req in case
* the config return value is used.
*/
req.config = function (cfg) {
return req(cfg);
};
/**
* Expose module registry for debugging and tooling
*/
requirejs._defined = defined;
define = function (name, deps, callback) {
if (typeof name !== 'string') {
throw new Error('See almond README: incorrect module build, no module name');
}
//This module may not have dependencies
if (!deps.splice) {
//deps is not an array, so probably means
//an object literal or factory function for
//the value. Adjust args.
callback = deps;
deps = [];
}
if (!hasProp(defined, name) && !hasProp(waiting, name)) {
waiting[name] = [name, deps, callback];
}
};
define.amd = {
jQuery: true
};
}());
S2.requirejs = requirejs;S2.require = require;S2.define = define;
}
}());
S2.define("almond", function(){});
/* global jQuery:false, $:false */
S2.define('jquery',[],function () {
var _$ = jQuery || $;
if (_$ == null && console && console.error) {
console.error(
'Select2: An instance of jQuery or a jQuery-compatible library was not ' +
'found. Make sure that you are including jQuery before Select2 on your ' +
'web page.'
);
}
return _$;
});
S2.define('select2/utils',[
'jquery'
], function ($) {
var Utils = {};
Utils.Extend = function (ChildClass, SuperClass) {
var __hasProp = {}.hasOwnProperty;
function BaseConstructor () {
this.constructor = ChildClass;
}
for (var key in SuperClass) {
if (__hasProp.call(SuperClass, key)) {
ChildClass[key] = SuperClass[key];
}
}
BaseConstructor.prototype = SuperClass.prototype;
ChildClass.prototype = new BaseConstructor();
ChildClass.__super__ = SuperClass.prototype;
return ChildClass;
};
function getMethods (theClass) {
var proto = theClass.prototype;
var methods = [];
for (var methodName in proto) {
var m = proto[methodName];
if (typeof m !== 'function') {
continue;
}
if (methodName === 'constructor') {
continue;
}
methods.push(methodName);
}
return methods;
}
Utils.Decorate = function (SuperClass, DecoratorClass) {
var decoratedMethods = getMethods(DecoratorClass);
var superMethods = getMethods(SuperClass);
function DecoratedClass () {
var unshift = Array.prototype.unshift;
var argCount = DecoratorClass.prototype.constructor.length;
var calledConstructor = SuperClass.prototype.constructor;
if (argCount > 0) {
unshift.call(arguments, SuperClass.prototype.constructor);
calledConstructor = DecoratorClass.prototype.constructor;
}
calledConstructor.apply(this, arguments);
}
DecoratorClass.displayName = SuperClass.displayName;
function ctr () {
this.constructor = DecoratedClass;
}
DecoratedClass.prototype = new ctr();
for (var m = 0; m < superMethods.length; m++) {
var superMethod = superMethods[m];
DecoratedClass.prototype[superMethod] =
SuperClass.prototype[superMethod];
}
var calledMethod = function (methodName) {
// Stub out the original method if it's not decorating an actual method
var originalMethod = function () {};
if (methodName in DecoratedClass.prototype) {
originalMethod = DecoratedClass.prototype[methodName];
}
var decoratedMethod = DecoratorClass.prototype[methodName];
return function () {
var unshift = Array.prototype.unshift;
unshift.call(arguments, originalMethod);
return decoratedMethod.apply(this, arguments);
};
};
for (var d = 0; d < decoratedMethods.length; d++) {
var decoratedMethod = decoratedMethods[d];
DecoratedClass.prototype[decoratedMethod] = calledMethod(decoratedMethod);
}
return DecoratedClass;
};
var Observable = function () {
this.listeners = {};
};
Observable.prototype.on = function (event, callback) {
this.listeners = this.listeners || {};
if (event in this.listeners) {
this.listeners[event].push(callback);
} else {
this.listeners[event] = [callback];
}
};
Observable.prototype.trigger = function (event) {
var slice = Array.prototype.slice;
var params = slice.call(arguments, 1);
this.listeners = this.listeners || {};
// Params should always come in as an array
if (params == null) {
params = [];
}
// If there are no arguments to the event, use a temporary object
if (params.length === 0) {
params.push({});
}
// Set the `_type` of the first object to the event
params[0]._type = event;
if (event in this.listeners) {
this.invoke(this.listeners[event], slice.call(arguments, 1));
}
if ('*' in this.listeners) {
this.invoke(this.listeners['*'], arguments);
}
};
Observable.prototype.invoke = function (listeners, params) {
for (var i = 0, len = listeners.length; i < len; i++) {
listeners[i].apply(this, params);
}
};
Utils.Observable = Observable;
Utils.generateChars = function (length) {
var chars = '';
for (var i = 0; i < length; i++) {
var randomChar = Math.floor(Math.random() * 36);
chars += randomChar.toString(36);
}
return chars;
};
Utils.bind = function (func, context) {
return function () {
func.apply(context, arguments);
};
};
Utils._convertData = function (data) {
for (var originalKey in data) {
var keys = originalKey.split('-');
var dataLevel = data;
if (keys.length === 1) {
continue;
}
for (var k = 0; k < keys.length; k++) {
var key = keys[k];
// Lowercase the first letter
// By default, dash-separated becomes camelCase
key = key.substring(0, 1).toLowerCase() + key.substring(1);
if (!(key in dataLevel)) {
dataLevel[key] = {};
}
if (k == keys.length - 1) {
dataLevel[key] = data[originalKey];
}
dataLevel = dataLevel[key];
}
delete data[originalKey];
}
return data;
};
Utils.hasScroll = function (index, el) {
// Adapted from the function created by @ShadowScripter
// and adapted by @BillBarry on the Stack Exchange Code Review website.
// The original code can be found at
// http://codereview.stackexchange.com/q/13338
// and was designed to be used with the Sizzle selector engine.
var $el = $(el);
var overflowX = el.style.overflowX;
var overflowY = el.style.overflowY;
//Check both x and y declarations
if (overflowX === overflowY &&
(overflowY === 'hidden' || overflowY === 'visible')) {
return false;
}
if (overflowX === 'scroll' || overflowY === 'scroll') {
return true;
}
return ($el.innerHeight() < el.scrollHeight ||
$el.innerWidth() < el.scrollWidth);
};
Utils.escapeMarkup = function (markup) {
var replaceMap = {
'\\': '\',
'&': '&',
'<': '<',
'>': '>',
'"': '"',
'\'': ''',
'/': '/'
};
// Do not try to escape the markup if it's not a string
if (typeof markup !== 'string') {
return markup;
}
return String(markup).replace(/[&<>"'\/\\]/g, function (match) {
return replaceMap[match];
});
};
// Cache objects in Utils.__cache instead of $.data (see #4346)
Utils.__cache = {};
var id = 0;
Utils.GetUniqueElementId = function (element) {
// Get a unique element Id. If element has no id,
// creates a new unique number, stores it in the id
// attribute and returns the new id with a prefix.
// If an id already exists, it simply returns it with a prefix.
var select2Id = element.getAttribute('data-select2-id');
if (select2Id != null) {
return select2Id;
}
// If element has id, use it.
if (element.id) {
select2Id = 'select2-data-' + element.id;
} else {
select2Id = 'select2-data-' + (++id).toString() +
'-' + Utils.generateChars(4);
}
element.setAttribute('data-select2-id', select2Id);
return select2Id;
};
Utils.StoreData = function (element, name, value) {
// Stores an item in the cache for a specified element.
// name is the cache key.
var id = Utils.GetUniqueElementId(element);
if (!Utils.__cache[id]) {
Utils.__cache[id] = {};
}
Utils.__cache[id][name] = value;
};
Utils.GetData = function (element, name) {
// Retrieves a value from the cache by its key (name)
// name is optional. If no name specified, return
// all cache items for the specified element.
// and for a specified element.
var id = Utils.GetUniqueElementId(element);
if (name) {
if (Utils.__cache[id]) {
if (Utils.__cache[id][name] != null) {
return Utils.__cache[id][name];
}
return $(element).data(name); // Fallback to HTML5 data attribs.
}
return $(element).data(name); // Fallback to HTML5 data attribs.
} else {
return Utils.__cache[id];
}
};
Utils.RemoveData = function (element) {
// Removes all cached items for a specified element.
var id = Utils.GetUniqueElementId(element);
if (Utils.__cache[id] != null) {
delete Utils.__cache[id];
}
element.removeAttribute('data-select2-id');
};
Utils.copyNonInternalCssClasses = function (dest, src) {
var classes;
var destinationClasses = dest.getAttribute('class').trim().split(/\s+/);
destinationClasses = destinationClasses.filter(function (clazz) {
// Save all Select2 classes
return clazz.indexOf('select2-') === 0;
});
var sourceClasses = src.getAttribute('class').trim().split(/\s+/);
sourceClasses = sourceClasses.filter(function (clazz) {
// Only copy non-Select2 classes
return clazz.indexOf('select2-') !== 0;
});
var replacements = destinationClasses.concat(sourceClasses);
dest.setAttribute('class', replacements.join(' '));
};
return Utils;
});
S2.define('select2/results',[
'jquery',
'./utils'
], function ($, Utils) {
function Results ($element, options, dataAdapter) {
this.$element = $element;
this.data = dataAdapter;
this.options = options;
Results.__super__.constructor.call(this);
}
Utils.Extend(Results, Utils.Observable);
Results.prototype.render = function () {
var $results = $(
'
'
);
if (this.options.get('multiple')) {
$results.attr('aria-multiselectable', 'true');
}
this.$results = $results;
return $results;
};
Results.prototype.clear = function () {
this.$results.empty();
};
Results.prototype.displayMessage = function (params) {
var escapeMarkup = this.options.get('escapeMarkup');
this.clear();
this.hideLoading();
var $message = $(
''
);
var message = this.options.get('translations').get(params.message);
$message.append(
escapeMarkup(
message(params.args)
)
);
$message[0].className += ' select2-results__message';
this.$results.append($message);
};
Results.prototype.hideMessages = function () {
this.$results.find('.select2-results__message').remove();
};
Results.prototype.append = function (data) {
this.hideLoading();
var $options = [];
if (data.results == null || data.results.length === 0) {
if (this.$results.children().length === 0) {
this.trigger('results:message', {
message: 'noResults'
});
}
return;
}
data.results = this.sort(data.results);
for (var d = 0; d < data.results.length; d++) {
var item = data.results[d];
var $option = this.option(item);
$options.push($option);
}
this.$results.append($options);
};
Results.prototype.position = function ($results, $dropdown) {
var $resultsContainer = $dropdown.find('.select2-results');
$resultsContainer.append($results);
};
Results.prototype.sort = function (data) {
var sorter = this.options.get('sorter');
return sorter(data);
};
Results.prototype.highlightFirstItem = function () {
var $options = this.$results
.find('.select2-results__option--selectable');
var $selected = $options.filter('.select2-results__option--selected');
// Check if there are any selected options
if ($selected.length > 0) {
// If there are selected options, highlight the first
$selected.first().trigger('mouseenter');
} else {
// If there are no selected options, highlight the first option
// in the dropdown
$options.first().trigger('mouseenter');
}
this.ensureHighlightVisible();
};
Results.prototype.setClasses = function () {
var self = this;
this.data.current(function (selected) {
var selectedIds = selected.map(function (s) {
return s.id.toString();
});
var $options = self.$results
.find('.select2-results__option--selectable');
$options.each(function () {
var $option = $(this);
var item = Utils.GetData(this, 'data');
// id needs to be converted to a string when comparing
var id = '' + item.id;
if ((item.element != null && item.element.selected) ||
(item.element == null && selectedIds.indexOf(id) > -1)) {
this.classList.add('select2-results__option--selected');
$option.attr('aria-selected', 'true');
} else {
this.classList.remove('select2-results__option--selected');
$option.attr('aria-selected', 'false');
}
});
});
};
Results.prototype.showLoading = function (params) {
this.hideLoading();
var loadingMore = this.options.get('translations').get('searching');
var loading = {
disabled: true,
loading: true,
text: loadingMore(params)
};
var $loading = this.option(loading);
$loading.className += ' loading-results';
this.$results.prepend($loading);
};
Results.prototype.hideLoading = function () {
this.$results.find('.loading-results').remove();
};
Results.prototype.option = function (data) {
var option = document.createElement('li');
option.classList.add('select2-results__option');
option.classList.add('select2-results__option--selectable');
var attrs = {
'role': 'option'
};
var matches = window.Element.prototype.matches ||
window.Element.prototype.msMatchesSelector ||
window.Element.prototype.webkitMatchesSelector;
if ((data.element != null && matches.call(data.element, ':disabled')) ||
(data.element == null && data.disabled)) {
attrs['aria-disabled'] = 'true';
option.classList.remove('select2-results__option--selectable');
option.classList.add('select2-results__option--disabled');
}
if (data.id == null) {
option.classList.remove('select2-results__option--selectable');
}
if (data._resultId != null) {
option.id = data._resultId;
}
if (data.title) {
option.title = data.title;
}
if (data.children) {
attrs.role = 'group';
attrs['aria-label'] = data.text;
option.classList.remove('select2-results__option--selectable');
option.classList.add('select2-results__option--group');
}
for (var attr in attrs) {
var val = attrs[attr];
option.setAttribute(attr, val);
}
if (data.children) {
var $option = $(option);
var label = document.createElement('strong');
label.className = 'select2-results__group';
this.template(data, label);
var $children = [];
for (var c = 0; c < data.children.length; c++) {
var child = data.children[c];
var $child = this.option(child);
$children.push($child);
}
var $childrenContainer = $('
', {
'class': 'select2-results__options select2-results__options--nested',
'role': 'none'
});
$childrenContainer.append($children);
$option.append(label);
$option.append($childrenContainer);
} else {
this.template(data, option);
}
Utils.StoreData(option, 'data', data);
return option;
};
Results.prototype.bind = function (container, $container) {
var self = this;
var id = container.id + '-results';
this.$results.attr('id', id);
container.on('results:all', function (params) {
self.clear();
self.append(params.data);
if (container.isOpen()) {
self.setClasses();
self.highlightFirstItem();
}
});
container.on('results:append', function (params) {
self.append(params.data);
if (container.isOpen()) {
self.setClasses();
}
});
container.on('query', function (params) {
self.hideMessages();
self.showLoading(params);
});
container.on('select', function () {
if (!container.isOpen()) {
return;
}
self.setClasses();
if (self.options.get('scrollAfterSelect')) {
self.highlightFirstItem();
}
});
container.on('unselect', function () {
if (!container.isOpen()) {
return;
}
self.setClasses();
if (self.options.get('scrollAfterSelect')) {
self.highlightFirstItem();
}
});
container.on('open', function () {
// When the dropdown is open, aria-expended="true"
self.$results.attr('aria-expanded', 'true');
self.$results.attr('aria-hidden', 'false');
self.setClasses();
self.ensureHighlightVisible();
});
container.on('close', function () {
// When the dropdown is closed, aria-expended="false"
self.$results.attr('aria-expanded', 'false');
self.$results.attr('aria-hidden', 'true');
self.$results.removeAttr('aria-activedescendant');
});
container.on('results:toggle', function () {
var $highlighted = self.getHighlightedResults();
if ($highlighted.length === 0) {
return;
}
$highlighted.trigger('mouseup');
});
container.on('results:select', function () {
var $highlighted = self.getHighlightedResults();
if ($highlighted.length === 0) {
return;
}
var data = Utils.GetData($highlighted[0], 'data');
if ($highlighted.hasClass('select2-results__option--selected')) {
self.trigger('close', {});
} else {
self.trigger('select', {
data: data
});
}
});
container.on('results:previous', function () {
var $highlighted = self.getHighlightedResults();
var $options = self.$results.find('.select2-results__option--selectable');
var currentIndex = $options.index($highlighted);
// If we are already at the top, don't move further
// If no options, currentIndex will be -1
if (currentIndex <= 0) {
return;
}
var nextIndex = currentIndex - 1;
// If none are highlighted, highlight the first
if ($highlighted.length === 0) {
nextIndex = 0;
}
var $next = $options.eq(nextIndex);
$next.trigger('mouseenter');
var currentOffset = self.$results.offset().top;
var nextTop = $next.offset().top;
var nextOffset = self.$results.scrollTop() + (nextTop - currentOffset);
if (nextIndex === 0) {
self.$results.scrollTop(0);
} else if (nextTop - currentOffset < 0) {
self.$results.scrollTop(nextOffset);
}
});
container.on('results:next', function () {
var $highlighted = self.getHighlightedResults();
var $options = self.$results.find('.select2-results__option--selectable');
var currentIndex = $options.index($highlighted);
var nextIndex = currentIndex + 1;
// If we are at the last option, stay there
if (nextIndex >= $options.length) {
return;
}
var $next = $options.eq(nextIndex);
$next.trigger('mouseenter');
var currentOffset = self.$results.offset().top +
self.$results.outerHeight(false);
var nextBottom = $next.offset().top + $next.outerHeight(false);
var nextOffset = self.$results.scrollTop() + nextBottom - currentOffset;
if (nextIndex === 0) {
self.$results.scrollTop(0);
} else if (nextBottom > currentOffset) {
self.$results.scrollTop(nextOffset);
}
});
container.on('results:focus', function (params) {
params.element[0].classList.add('select2-results__option--highlighted');
params.element[0].setAttribute('aria-selected', 'true');
});
container.on('results:message', function (params) {
self.displayMessage(params);
});
if ($.fn.mousewheel) {
this.$results.on('mousewheel', function (e) {
var top = self.$results.scrollTop();
var bottom = self.$results.get(0).scrollHeight - top + e.deltaY;
var isAtTop = e.deltaY > 0 && top - e.deltaY <= 0;
var isAtBottom = e.deltaY < 0 && bottom <= self.$results.height();
if (isAtTop) {
self.$results.scrollTop(0);
e.preventDefault();
e.stopPropagation();
} else if (isAtBottom) {
self.$results.scrollTop(
self.$results.get(0).scrollHeight - self.$results.height()
);
e.preventDefault();
e.stopPropagation();
}
});
}
this.$results.on('mouseup', '.select2-results__option--selectable',
function (evt) {
var $this = $(this);
var data = Utils.GetData(this, 'data');
if ($this.hasClass('select2-results__option--selected')) {
if (self.options.get('multiple')) {
self.trigger('unselect', {
originalEvent: evt,
data: data
});
} else {
self.trigger('close', {});
}
return;
}
self.trigger('select', {
originalEvent: evt,
data: data
});
});
this.$results.on('mouseenter', '.select2-results__option--selectable',
function (evt) {
var data = Utils.GetData(this, 'data');
self.getHighlightedResults()
.removeClass('select2-results__option--highlighted')
.attr('aria-selected', 'false');
self.trigger('results:focus', {
data: data,
element: $(this)
});
});
};
Results.prototype.getHighlightedResults = function () {
var $highlighted = this.$results
.find('.select2-results__option--highlighted');
return $highlighted;
};
Results.prototype.destroy = function () {
this.$results.remove();
};
Results.prototype.ensureHighlightVisible = function () {
var $highlighted = this.getHighlightedResults();
if ($highlighted.length === 0) {
return;
}
var $options = this.$results.find('.select2-results__option--selectable');
var currentIndex = $options.index($highlighted);
var currentOffset = this.$results.offset().top;
var nextTop = $highlighted.offset().top;
var nextOffset = this.$results.scrollTop() + (nextTop - currentOffset);
var offsetDelta = nextTop - currentOffset;
nextOffset -= $highlighted.outerHeight(false) * 2;
if (currentIndex <= 2) {
this.$results.scrollTop(0);
} else if (offsetDelta > this.$results.outerHeight() || offsetDelta < 0) {
this.$results.scrollTop(nextOffset);
}
};
Results.prototype.template = function (result, container) {
var template = this.options.get('templateResult');
var escapeMarkup = this.options.get('escapeMarkup');
var content = template(result, container);
if (content == null) {
container.style.display = 'none';
} else if (typeof content === 'string') {
container.innerHTML = escapeMarkup(content);
} else {
$(container).append(content);
}
};
return Results;
});
S2.define('select2/keys',[
], function () {
var KEYS = {
BACKSPACE: 8,
TAB: 9,
ENTER: 13,
SHIFT: 16,
CTRL: 17,
ALT: 18,
ESC: 27,
SPACE: 32,
PAGE_UP: 33,
PAGE_DOWN: 34,
END: 35,
HOME: 36,
LEFT: 37,
UP: 38,
RIGHT: 39,
DOWN: 40,
DELETE: 46
};
return KEYS;
});
S2.define('select2/selection/base',[
'jquery',
'../utils',
'../keys'
], function ($, Utils, KEYS) {
function BaseSelection ($element, options) {
this.$element = $element;
this.options = options;
BaseSelection.__super__.constructor.call(this);
}
Utils.Extend(BaseSelection, Utils.Observable);
BaseSelection.prototype.render = function () {
var $selection = $(
'' +
''
);
this._tabindex = 0;
if (Utils.GetData(this.$element[0], 'old-tabindex') != null) {
this._tabindex = Utils.GetData(this.$element[0], 'old-tabindex');
} else if (this.$element.attr('tabindex') != null) {
this._tabindex = this.$element.attr('tabindex');
}
$selection.attr('title', this.$element.attr('title'));
$selection.attr('tabindex', this._tabindex);
$selection.attr('aria-disabled', 'false');
this.$selection = $selection;
return $selection;
};
BaseSelection.prototype.bind = function (container, $container) {
var self = this;
var resultsId = container.id + '-results';
this.container = container;
this.$selection.on('focus', function (evt) {
self.trigger('focus', evt);
});
this.$selection.on('blur', function (evt) {
self._handleBlur(evt);
});
this.$selection.on('keydown', function (evt) {
self.trigger('keypress', evt);
if (evt.which === KEYS.SPACE) {
evt.preventDefault();
}
});
container.on('results:focus', function (params) {
self.$selection.attr('aria-activedescendant', params.data._resultId);
});
container.on('selection:update', function (params) {
self.update(params.data);
});
container.on('open', function () {
// When the dropdown is open, aria-expanded="true"
self.$selection.attr('aria-expanded', 'true');
self.$selection.attr('aria-owns', resultsId);
self._attachCloseHandler(container);
});
container.on('close', function () {
// When the dropdown is closed, aria-expanded="false"
self.$selection.attr('aria-expanded', 'false');
self.$selection.removeAttr('aria-activedescendant');
self.$selection.removeAttr('aria-owns');
self.$selection.trigger('focus');
self._detachCloseHandler(container);
});
container.on('enable', function () {
self.$selection.attr('tabindex', self._tabindex);
self.$selection.attr('aria-disabled', 'false');
});
container.on('disable', function () {
self.$selection.attr('tabindex', '-1');
self.$selection.attr('aria-disabled', 'true');
});
};
BaseSelection.prototype._handleBlur = function (evt) {
var self = this;
// This needs to be delayed as the active element is the body when the tab
// key is pressed, possibly along with others.
window.setTimeout(function () {
// Don't trigger `blur` if the focus is still in the selection
if (
(document.activeElement == self.$selection[0]) ||
($.contains(self.$selection[0], document.activeElement))
) {
return;
}
self.trigger('blur', evt);
}, 1);
};
BaseSelection.prototype._attachCloseHandler = function (container) {
$(document.body).on('mousedown.select2.' + container.id, function (e) {
var $target = $(e.target);
var $select = $target.closest('.select2');
var $all = $('.select2.select2-container--open');
$all.each(function () {
if (this == $select[0]) {
return;
}
var $element = Utils.GetData(this, 'element');
$element.select2('close');
});
});
};
BaseSelection.prototype._detachCloseHandler = function (container) {
$(document.body).off('mousedown.select2.' + container.id);
};
BaseSelection.prototype.position = function ($selection, $container) {
var $selectionContainer = $container.find('.selection');
$selectionContainer.append($selection);
};
BaseSelection.prototype.destroy = function () {
this._detachCloseHandler(this.container);
};
BaseSelection.prototype.update = function (data) {
throw new Error('The `update` method must be defined in child classes.');
};
/**
* Helper method to abstract the "enabled" (not "disabled") state of this
* object.
*
* @return {true} if the instance is not disabled.
* @return {false} if the instance is disabled.
*/
BaseSelection.prototype.isEnabled = function () {
return !this.isDisabled();
};
/**
* Helper method to abstract the "disabled" state of this object.
*
* @return {true} if the disabled option is true.
* @return {false} if the disabled option is false.
*/
BaseSelection.prototype.isDisabled = function () {
return this.options.get('disabled');
};
return BaseSelection;
});
S2.define('select2/selection/single',[
'jquery',
'./base',
'../utils',
'../keys'
], function ($, BaseSelection, Utils, KEYS) {
function SingleSelection () {
SingleSelection.__super__.constructor.apply(this, arguments);
}
Utils.Extend(SingleSelection, BaseSelection);
SingleSelection.prototype.render = function () {
var $selection = SingleSelection.__super__.render.call(this);
$selection[0].classList.add('select2-selection--single');
$selection.html(
'' +
'' +
'' +
''
);
return $selection;
};
SingleSelection.prototype.bind = function (container, $container) {
var self = this;
SingleSelection.__super__.bind.apply(this, arguments);
var id = container.id + '-container';
this.$selection.find('.select2-selection__rendered')
.attr('id', id)
.attr('role', 'textbox')
.attr('aria-readonly', 'true');
this.$selection.attr('aria-labelledby', id);
this.$selection.attr('aria-controls', id);
this.$selection.on('mousedown', function (evt) {
// Only respond to left clicks
if (evt.which !== 1) {
return;
}
self.trigger('toggle', {
originalEvent: evt
});
});
this.$selection.on('focus', function (evt) {
// User focuses on the container
});
this.$selection.on('blur', function (evt) {
// User exits the container
});
container.on('focus', function (evt) {
if (!container.isOpen()) {
self.$selection.trigger('focus');
}
});
};
SingleSelection.prototype.clear = function () {
var $rendered = this.$selection.find('.select2-selection__rendered');
$rendered.empty();
$rendered.removeAttr('title'); // clear tooltip on empty
};
SingleSelection.prototype.display = function (data, container) {
var template = this.options.get('templateSelection');
var escapeMarkup = this.options.get('escapeMarkup');
return escapeMarkup(template(data, container));
};
SingleSelection.prototype.selectionContainer = function () {
return $('');
};
SingleSelection.prototype.update = function (data) {
if (data.length === 0) {
this.clear();
return;
}
var selection = data[0];
var $rendered = this.$selection.find('.select2-selection__rendered');
var formatted = this.display(selection, $rendered);
$rendered.empty().append(formatted);
var title = selection.title || selection.text;
if (title) {
$rendered.attr('title', title);
} else {
$rendered.removeAttr('title');
}
};
return SingleSelection;
});
S2.define('select2/selection/multiple',[
'jquery',
'./base',
'../utils'
], function ($, BaseSelection, Utils) {
function MultipleSelection ($element, options) {
MultipleSelection.__super__.constructor.apply(this, arguments);
}
Utils.Extend(MultipleSelection, BaseSelection);
MultipleSelection.prototype.render = function () {
var $selection = MultipleSelection.__super__.render.call(this);
$selection[0].classList.add('select2-selection--multiple');
$selection.html(
'
'
);
return $selection;
};
MultipleSelection.prototype.bind = function (container, $container) {
var self = this;
MultipleSelection.__super__.bind.apply(this, arguments);
var id = container.id + '-container';
this.$selection.find('.select2-selection__rendered').attr('id', id);
this.$selection.on('click', function (evt) {
self.trigger('toggle', {
originalEvent: evt
});
});
this.$selection.on(
'click',
'.select2-selection__choice__remove',
function (evt) {
// Ignore the event if it is disabled
if (self.isDisabled()) {
return;
}
var $remove = $(this);
var $selection = $remove.parent();
var data = Utils.GetData($selection[0], 'data');
self.trigger('unselect', {
originalEvent: evt,
data: data
});
}
);
this.$selection.on(
'keydown',
'.select2-selection__choice__remove',
function (evt) {
// Ignore the event if it is disabled
if (self.isDisabled()) {
return;
}
evt.stopPropagation();
}
);
};
MultipleSelection.prototype.clear = function () {
var $rendered = this.$selection.find('.select2-selection__rendered');
$rendered.empty();
$rendered.removeAttr('title');
};
MultipleSelection.prototype.display = function (data, container) {
var template = this.options.get('templateSelection');
var escapeMarkup = this.options.get('escapeMarkup');
return escapeMarkup(template(data, container));
};
MultipleSelection.prototype.selectionContainer = function () {
var $container = $(
'
' +
'' +
'' +
'
'
);
return $container;
};
MultipleSelection.prototype.update = function (data) {
this.clear();
if (data.length === 0) {
return;
}
var $selections = [];
var selectionIdPrefix = this.$selection.find('.select2-selection__rendered')
.attr('id') + '-choice-';
for (var d = 0; d < data.length; d++) {
var selection = data[d];
var $selection = this.selectionContainer();
var formatted = this.display(selection, $selection);
var selectionId = selectionIdPrefix + Utils.generateChars(4) + '-';
if (selection.id) {
selectionId += selection.id;
} else {
selectionId += Utils.generateChars(4);
}
$selection.find('.select2-selection__choice__display')
.append(formatted)
.attr('id', selectionId);
var title = selection.title || selection.text;
if (title) {
$selection.attr('title', title);
}
var removeItem = this.options.get('translations').get('removeItem');
var $remove = $selection.find('.select2-selection__choice__remove');
$remove.attr('title', removeItem());
$remove.attr('aria-label', removeItem());
$remove.attr('aria-describedby', selectionId);
Utils.StoreData($selection[0], 'data', selection);
$selections.push($selection);
}
var $rendered = this.$selection.find('.select2-selection__rendered');
$rendered.append($selections);
};
return MultipleSelection;
});
S2.define('select2/selection/placeholder',[
], function () {
function Placeholder (decorated, $element, options) {
this.placeholder = this.normalizePlaceholder(options.get('placeholder'));
decorated.call(this, $element, options);
}
Placeholder.prototype.normalizePlaceholder = function (_, placeholder) {
if (typeof placeholder === 'string') {
placeholder = {
id: '',
text: placeholder
};
}
return placeholder;
};
Placeholder.prototype.createPlaceholder = function (decorated, placeholder) {
var $placeholder = this.selectionContainer();
$placeholder.html(this.display(placeholder));
$placeholder[0].classList.add('select2-selection__placeholder');
$placeholder[0].classList.remove('select2-selection__choice');
var placeholderTitle = placeholder.title ||
placeholder.text ||
$placeholder.text();
this.$selection.find('.select2-selection__rendered').attr(
'title',
placeholderTitle
);
return $placeholder;
};
Placeholder.prototype.update = function (decorated, data) {
var singlePlaceholder = (
data.length == 1 && data[0].id != this.placeholder.id
);
var multipleSelections = data.length > 1;
if (multipleSelections || singlePlaceholder) {
return decorated.call(this, data);
}
this.clear();
var $placeholder = this.createPlaceholder(this.placeholder);
this.$selection.find('.select2-selection__rendered').append($placeholder);
};
return Placeholder;
});
S2.define('select2/selection/allowClear',[
'jquery',
'../keys',
'../utils'
], function ($, KEYS, Utils) {
function AllowClear () { }
AllowClear.prototype.bind = function (decorated, container, $container) {
var self = this;
decorated.call(this, container, $container);
if (this.placeholder == null) {
if (this.options.get('debug') && window.console && console.error) {
console.error(
'Select2: The `allowClear` option should be used in combination ' +
'with the `placeholder` option.'
);
}
}
this.$selection.on('mousedown', '.select2-selection__clear',
function (evt) {
self._handleClear(evt);
});
container.on('keypress', function (evt) {
self._handleKeyboardClear(evt, container);
});
};
AllowClear.prototype._handleClear = function (_, evt) {
// Ignore the event if it is disabled
if (this.isDisabled()) {
return;
}
var $clear = this.$selection.find('.select2-selection__clear');
// Ignore the event if nothing has been selected
if ($clear.length === 0) {
return;
}
evt.stopPropagation();
var data = Utils.GetData($clear[0], 'data');
var previousVal = this.$element.val();
this.$element.val(this.placeholder.id);
var unselectData = {
data: data
};
this.trigger('clear', unselectData);
if (unselectData.prevented) {
this.$element.val(previousVal);
return;
}
for (var d = 0; d < data.length; d++) {
unselectData = {
data: data[d]
};
// Trigger the `unselect` event, so people can prevent it from being
// cleared.
this.trigger('unselect', unselectData);
// If the event was prevented, don't clear it out.
if (unselectData.prevented) {
this.$element.val(previousVal);
return;
}
}
this.$element.trigger('input').trigger('change');
this.trigger('toggle', {});
};
AllowClear.prototype._handleKeyboardClear = function (_, evt, container) {
if (container.isOpen()) {
return;
}
if (evt.which == KEYS.DELETE || evt.which == KEYS.BACKSPACE) {
this._handleClear(evt);
}
};
AllowClear.prototype.update = function (decorated, data) {
decorated.call(this, data);
this.$selection.find('.select2-selection__clear').remove();
this.$selection[0].classList.remove('select2-selection--clearable');
if (this.$selection.find('.select2-selection__placeholder').length > 0 ||
data.length === 0) {
return;
}
var selectionId = this.$selection.find('.select2-selection__rendered')
.attr('id');
var removeAll = this.options.get('translations').get('removeAllItems');
var $remove = $(
''
);
$remove.attr('title', removeAll());
$remove.attr('aria-label', removeAll());
$remove.attr('aria-describedby', selectionId);
Utils.StoreData($remove[0], 'data', data);
this.$selection.prepend($remove);
this.$selection[0].classList.add('select2-selection--clearable');
};
return AllowClear;
});
S2.define('select2/selection/search',[
'jquery',
'../utils',
'../keys'
], function ($, Utils, KEYS) {
function Search (decorated, $element, options) {
decorated.call(this, $element, options);
}
Search.prototype.render = function (decorated) {
var searchLabel = this.options.get('translations').get('search');
var $search = $(
'' +
'' +
''
);
this.$searchContainer = $search;
this.$search = $search.find('textarea');
this.$search.prop('autocomplete', this.options.get('autocomplete'));
this.$search.attr('aria-label', searchLabel());
var $rendered = decorated.call(this);
this._transferTabIndex();
$rendered.append(this.$searchContainer);
return $rendered;
};
Search.prototype.bind = function (decorated, container, $container) {
var self = this;
var resultsId = container.id + '-results';
var selectionId = container.id + '-container';
decorated.call(this, container, $container);
self.$search.attr('aria-describedby', selectionId);
container.on('open', function () {
self.$search.attr('aria-controls', resultsId);
self.$search.trigger('focus');
});
container.on('close', function () {
self.$search.val('');
self.resizeSearch();
self.$search.removeAttr('aria-controls');
self.$search.removeAttr('aria-activedescendant');
self.$search.trigger('focus');
});
container.on('enable', function () {
self.$search.prop('disabled', false);
self._transferTabIndex();
});
container.on('disable', function () {
self.$search.prop('disabled', true);
});
container.on('focus', function (evt) {
self.$search.trigger('focus');
});
container.on('results:focus', function (params) {
if (params.data._resultId) {
self.$search.attr('aria-activedescendant', params.data._resultId);
} else {
self.$search.removeAttr('aria-activedescendant');
}
});
this.$selection.on('focusin', '.select2-search--inline', function (evt) {
self.trigger('focus', evt);
});
this.$selection.on('focusout', '.select2-search--inline', function (evt) {
self._handleBlur(evt);
});
this.$selection.on('keydown', '.select2-search--inline', function (evt) {
evt.stopPropagation();
self.trigger('keypress', evt);
self._keyUpPrevented = evt.isDefaultPrevented();
var key = evt.which;
if (key === KEYS.BACKSPACE && self.$search.val() === '') {
var $previousChoice = self.$selection
.find('.select2-selection__choice').last();
if ($previousChoice.length > 0) {
var item = Utils.GetData($previousChoice[0], 'data');
self.searchRemoveChoice(item);
evt.preventDefault();
}
}
});
this.$selection.on('click', '.select2-search--inline', function (evt) {
if (self.$search.val()) {
evt.stopPropagation();
}
});
// Try to detect the IE version should the `documentMode` property that
// is stored on the document. This is only implemented in IE and is
// slightly cleaner than doing a user agent check.
// This property is not available in Edge, but Edge also doesn't have
// this bug.
var msie = document.documentMode;
var disableInputEvents = msie && msie <= 11;
// Workaround for browsers which do not support the `input` event
// This will prevent double-triggering of events for browsers which support
// both the `keyup` and `input` events.
this.$selection.on(
'input.searchcheck',
'.select2-search--inline',
function (evt) {
// IE will trigger the `input` event when a placeholder is used on a
// search box. To get around this issue, we are forced to ignore all
// `input` events in IE and keep using `keyup`.
if (disableInputEvents) {
self.$selection.off('input.search input.searchcheck');
return;
}
// Unbind the duplicated `keyup` event
self.$selection.off('keyup.search');
}
);
this.$selection.on(
'keyup.search input.search',
'.select2-search--inline',
function (evt) {
// IE will trigger the `input` event when a placeholder is used on a
// search box. To get around this issue, we are forced to ignore all
// `input` events in IE and keep using `keyup`.
if (disableInputEvents && evt.type === 'input') {
self.$selection.off('input.search input.searchcheck');
return;
}
var key = evt.which;
// We can freely ignore events from modifier keys
if (key == KEYS.SHIFT || key == KEYS.CTRL || key == KEYS.ALT) {
return;
}
// Tabbing will be handled during the `keydown` phase
if (key == KEYS.TAB) {
return;
}
self.handleSearch(evt);
}
);
};
/**
* This method will transfer the tabindex attribute from the rendered
* selection to the search box. This allows for the search box to be used as
* the primary focus instead of the selection container.
*
* @private
*/
Search.prototype._transferTabIndex = function (decorated) {
this.$search.attr('tabindex', this.$selection.attr('tabindex'));
this.$selection.attr('tabindex', '-1');
};
Search.prototype.createPlaceholder = function (decorated, placeholder) {
this.$search.attr('placeholder', placeholder.text);
};
Search.prototype.update = function (decorated, data) {
var searchHadFocus = this.$search[0] == document.activeElement;
this.$search.attr('placeholder', '');
decorated.call(this, data);
this.resizeSearch();
if (searchHadFocus) {
this.$search.trigger('focus');
}
};
Search.prototype.handleSearch = function () {
this.resizeSearch();
if (!this._keyUpPrevented) {
var input = this.$search.val();
this.trigger('query', {
term: input
});
}
this._keyUpPrevented = false;
};
Search.prototype.searchRemoveChoice = function (decorated, item) {
this.trigger('unselect', {
data: item
});
this.$search.val(item.text);
this.handleSearch();
};
Search.prototype.resizeSearch = function () {
this.$search.css('width', '25px');
var width = '100%';
if (this.$search.attr('placeholder') === '') {
var minimumWidth = this.$search.val().length + 1;
width = (minimumWidth * 0.75) + 'em';
}
this.$search.css('width', width);
};
return Search;
});
S2.define('select2/selection/selectionCss',[
'../utils'
], function (Utils) {
function SelectionCSS () { }
SelectionCSS.prototype.render = function (decorated) {
var $selection = decorated.call(this);
var selectionCssClass = this.options.get('selectionCssClass') || '';
if (selectionCssClass.indexOf(':all:') !== -1) {
selectionCssClass = selectionCssClass.replace(':all:', '');
Utils.copyNonInternalCssClasses($selection[0], this.$element[0]);
}
$selection.addClass(selectionCssClass);
return $selection;
};
return SelectionCSS;
});
S2.define('select2/selection/eventRelay',[
'jquery'
], function ($) {
function EventRelay () { }
EventRelay.prototype.bind = function (decorated, container, $container) {
var self = this;
var relayEvents = [
'open', 'opening',
'close', 'closing',
'select', 'selecting',
'unselect', 'unselecting',
'clear', 'clearing'
];
var preventableEvents = [
'opening', 'closing', 'selecting', 'unselecting', 'clearing'
];
decorated.call(this, container, $container);
container.on('*', function (name, params) {
// Ignore events that should not be relayed
if (relayEvents.indexOf(name) === -1) {
return;
}
// The parameters should always be an object
params = params || {};
// Generate the jQuery event for the Select2 event
var evt = $.Event('select2:' + name, {
params: params
});
self.$element.trigger(evt);
// Only handle preventable events if it was one
if (preventableEvents.indexOf(name) === -1) {
return;
}
params.prevented = evt.isDefaultPrevented();
});
};
return EventRelay;
});
S2.define('select2/translation',[
'jquery',
'require'
], function ($, require) {
function Translation (dict) {
this.dict = dict || {};
}
Translation.prototype.all = function () {
return this.dict;
};
Translation.prototype.get = function (key) {
return this.dict[key];
};
Translation.prototype.extend = function (translation) {
this.dict = $.extend({}, translation.all(), this.dict);
};
// Static functions
Translation._cache = {};
Translation.loadPath = function (path) {
if (!(path in Translation._cache)) {
var translations = require(path);
Translation._cache[path] = translations;
}
return new Translation(Translation._cache[path]);
};
return Translation;
});
S2.define('select2/diacritics',[
], function () {
var diacritics = {
'\u24B6': 'A',
'\uFF21': 'A',
'\u00C0': 'A',
'\u00C1': 'A',
'\u00C2': 'A',
'\u1EA6': 'A',
'\u1EA4': 'A',
'\u1EAA': 'A',
'\u1EA8': 'A',
'\u00C3': 'A',
'\u0100': 'A',
'\u0102': 'A',
'\u1EB0': 'A',
'\u1EAE': 'A',
'\u1EB4': 'A',
'\u1EB2': 'A',
'\u0226': 'A',
'\u01E0': 'A',
'\u00C4': 'A',
'\u01DE': 'A',
'\u1EA2': 'A',
'\u00C5': 'A',
'\u01FA': 'A',
'\u01CD': 'A',
'\u0200': 'A',
'\u0202': 'A',
'\u1EA0': 'A',
'\u1EAC': 'A',
'\u1EB6': 'A',
'\u1E00': 'A',
'\u0104': 'A',
'\u023A': 'A',
'\u2C6F': 'A',
'\uA732': 'AA',
'\u00C6': 'AE',
'\u01FC': 'AE',
'\u01E2': 'AE',
'\uA734': 'AO',
'\uA736': 'AU',
'\uA738': 'AV',
'\uA73A': 'AV',
'\uA73C': 'AY',
'\u24B7': 'B',
'\uFF22': 'B',
'\u1E02': 'B',
'\u1E04': 'B',
'\u1E06': 'B',
'\u0243': 'B',
'\u0182': 'B',
'\u0181': 'B',
'\u24B8': 'C',
'\uFF23': 'C',
'\u0106': 'C',
'\u0108': 'C',
'\u010A': 'C',
'\u010C': 'C',
'\u00C7': 'C',
'\u1E08': 'C',
'\u0187': 'C',
'\u023B': 'C',
'\uA73E': 'C',
'\u24B9': 'D',
'\uFF24': 'D',
'\u1E0A': 'D',
'\u010E': 'D',
'\u1E0C': 'D',
'\u1E10': 'D',
'\u1E12': 'D',
'\u1E0E': 'D',
'\u0110': 'D',
'\u018B': 'D',
'\u018A': 'D',
'\u0189': 'D',
'\uA779': 'D',
'\u01F1': 'DZ',
'\u01C4': 'DZ',
'\u01F2': 'Dz',
'\u01C5': 'Dz',
'\u24BA': 'E',
'\uFF25': 'E',
'\u00C8': 'E',
'\u00C9': 'E',
'\u00CA': 'E',
'\u1EC0': 'E',
'\u1EBE': 'E',
'\u1EC4': 'E',
'\u1EC2': 'E',
'\u1EBC': 'E',
'\u0112': 'E',
'\u1E14': 'E',
'\u1E16': 'E',
'\u0114': 'E',
'\u0116': 'E',
'\u00CB': 'E',
'\u1EBA': 'E',
'\u011A': 'E',
'\u0204': 'E',
'\u0206': 'E',
'\u1EB8': 'E',
'\u1EC6': 'E',
'\u0228': 'E',
'\u1E1C': 'E',
'\u0118': 'E',
'\u1E18': 'E',
'\u1E1A': 'E',
'\u0190': 'E',
'\u018E': 'E',
'\u24BB': 'F',
'\uFF26': 'F',
'\u1E1E': 'F',
'\u0191': 'F',
'\uA77B': 'F',
'\u24BC': 'G',
'\uFF27': 'G',
'\u01F4': 'G',
'\u011C': 'G',
'\u1E20': 'G',
'\u011E': 'G',
'\u0120': 'G',
'\u01E6': 'G',
'\u0122': 'G',
'\u01E4': 'G',
'\u0193': 'G',
'\uA7A0': 'G',
'\uA77D': 'G',
'\uA77E': 'G',
'\u24BD': 'H',
'\uFF28': 'H',
'\u0124': 'H',
'\u1E22': 'H',
'\u1E26': 'H',
'\u021E': 'H',
'\u1E24': 'H',
'\u1E28': 'H',
'\u1E2A': 'H',
'\u0126': 'H',
'\u2C67': 'H',
'\u2C75': 'H',
'\uA78D': 'H',
'\u24BE': 'I',
'\uFF29': 'I',
'\u00CC': 'I',
'\u00CD': 'I',
'\u00CE': 'I',
'\u0128': 'I',
'\u012A': 'I',
'\u012C': 'I',
'\u0130': 'I',
'\u00CF': 'I',
'\u1E2E': 'I',
'\u1EC8': 'I',
'\u01CF': 'I',
'\u0208': 'I',
'\u020A': 'I',
'\u1ECA': 'I',
'\u012E': 'I',
'\u1E2C': 'I',
'\u0197': 'I',
'\u24BF': 'J',
'\uFF2A': 'J',
'\u0134': 'J',
'\u0248': 'J',
'\u24C0': 'K',
'\uFF2B': 'K',
'\u1E30': 'K',
'\u01E8': 'K',
'\u1E32': 'K',
'\u0136': 'K',
'\u1E34': 'K',
'\u0198': 'K',
'\u2C69': 'K',
'\uA740': 'K',
'\uA742': 'K',
'\uA744': 'K',
'\uA7A2': 'K',
'\u24C1': 'L',
'\uFF2C': 'L',
'\u013F': 'L',
'\u0139': 'L',
'\u013D': 'L',
'\u1E36': 'L',
'\u1E38': 'L',
'\u013B': 'L',
'\u1E3C': 'L',
'\u1E3A': 'L',
'\u0141': 'L',
'\u023D': 'L',
'\u2C62': 'L',
'\u2C60': 'L',
'\uA748': 'L',
'\uA746': 'L',
'\uA780': 'L',
'\u01C7': 'LJ',
'\u01C8': 'Lj',
'\u24C2': 'M',
'\uFF2D': 'M',
'\u1E3E': 'M',
'\u1E40': 'M',
'\u1E42': 'M',
'\u2C6E': 'M',
'\u019C': 'M',
'\u24C3': 'N',
'\uFF2E': 'N',
'\u01F8': 'N',
'\u0143': 'N',
'\u00D1': 'N',
'\u1E44': 'N',
'\u0147': 'N',
'\u1E46': 'N',
'\u0145': 'N',
'\u1E4A': 'N',
'\u1E48': 'N',
'\u0220': 'N',
'\u019D': 'N',
'\uA790': 'N',
'\uA7A4': 'N',
'\u01CA': 'NJ',
'\u01CB': 'Nj',
'\u24C4': 'O',
'\uFF2F': 'O',
'\u00D2': 'O',
'\u00D3': 'O',
'\u00D4': 'O',
'\u1ED2': 'O',
'\u1ED0': 'O',
'\u1ED6': 'O',
'\u1ED4': 'O',
'\u00D5': 'O',
'\u1E4C': 'O',
'\u022C': 'O',
'\u1E4E': 'O',
'\u014C': 'O',
'\u1E50': 'O',
'\u1E52': 'O',
'\u014E': 'O',
'\u022E': 'O',
'\u0230': 'O',
'\u00D6': 'O',
'\u022A': 'O',
'\u1ECE': 'O',
'\u0150': 'O',
'\u01D1': 'O',
'\u020C': 'O',
'\u020E': 'O',
'\u01A0': 'O',
'\u1EDC': 'O',
'\u1EDA': 'O',
'\u1EE0': 'O',
'\u1EDE': 'O',
'\u1EE2': 'O',
'\u1ECC': 'O',
'\u1ED8': 'O',
'\u01EA': 'O',
'\u01EC': 'O',
'\u00D8': 'O',
'\u01FE': 'O',
'\u0186': 'O',
'\u019F': 'O',
'\uA74A': 'O',
'\uA74C': 'O',
'\u0152': 'OE',
'\u01A2': 'OI',
'\uA74E': 'OO',
'\u0222': 'OU',
'\u24C5': 'P',
'\uFF30': 'P',
'\u1E54': 'P',
'\u1E56': 'P',
'\u01A4': 'P',
'\u2C63': 'P',
'\uA750': 'P',
'\uA752': 'P',
'\uA754': 'P',
'\u24C6': 'Q',
'\uFF31': 'Q',
'\uA756': 'Q',
'\uA758': 'Q',
'\u024A': 'Q',
'\u24C7': 'R',
'\uFF32': 'R',
'\u0154': 'R',
'\u1E58': 'R',
'\u0158': 'R',
'\u0210': 'R',
'\u0212': 'R',
'\u1E5A': 'R',
'\u1E5C': 'R',
'\u0156': 'R',
'\u1E5E': 'R',
'\u024C': 'R',
'\u2C64': 'R',
'\uA75A': 'R',
'\uA7A6': 'R',
'\uA782': 'R',
'\u24C8': 'S',
'\uFF33': 'S',
'\u1E9E': 'S',
'\u015A': 'S',
'\u1E64': 'S',
'\u015C': 'S',
'\u1E60': 'S',
'\u0160': 'S',
'\u1E66': 'S',
'\u1E62': 'S',
'\u1E68': 'S',
'\u0218': 'S',
'\u015E': 'S',
'\u2C7E': 'S',
'\uA7A8': 'S',
'\uA784': 'S',
'\u24C9': 'T',
'\uFF34': 'T',
'\u1E6A': 'T',
'\u0164': 'T',
'\u1E6C': 'T',
'\u021A': 'T',
'\u0162': 'T',
'\u1E70': 'T',
'\u1E6E': 'T',
'\u0166': 'T',
'\u01AC': 'T',
'\u01AE': 'T',
'\u023E': 'T',
'\uA786': 'T',
'\uA728': 'TZ',
'\u24CA': 'U',
'\uFF35': 'U',
'\u00D9': 'U',
'\u00DA': 'U',
'\u00DB': 'U',
'\u0168': 'U',
'\u1E78': 'U',
'\u016A': 'U',
'\u1E7A': 'U',
'\u016C': 'U',
'\u00DC': 'U',
'\u01DB': 'U',
'\u01D7': 'U',
'\u01D5': 'U',
'\u01D9': 'U',
'\u1EE6': 'U',
'\u016E': 'U',
'\u0170': 'U',
'\u01D3': 'U',
'\u0214': 'U',
'\u0216': 'U',
'\u01AF': 'U',
'\u1EEA': 'U',
'\u1EE8': 'U',
'\u1EEE': 'U',
'\u1EEC': 'U',
'\u1EF0': 'U',
'\u1EE4': 'U',
'\u1E72': 'U',
'\u0172': 'U',
'\u1E76': 'U',
'\u1E74': 'U',
'\u0244': 'U',
'\u24CB': 'V',
'\uFF36': 'V',
'\u1E7C': 'V',
'\u1E7E': 'V',
'\u01B2': 'V',
'\uA75E': 'V',
'\u0245': 'V',
'\uA760': 'VY',
'\u24CC': 'W',
'\uFF37': 'W',
'\u1E80': 'W',
'\u1E82': 'W',
'\u0174': 'W',
'\u1E86': 'W',
'\u1E84': 'W',
'\u1E88': 'W',
'\u2C72': 'W',
'\u24CD': 'X',
'\uFF38': 'X',
'\u1E8A': 'X',
'\u1E8C': 'X',
'\u24CE': 'Y',
'\uFF39': 'Y',
'\u1EF2': 'Y',
'\u00DD': 'Y',
'\u0176': 'Y',
'\u1EF8': 'Y',
'\u0232': 'Y',
'\u1E8E': 'Y',
'\u0178': 'Y',
'\u1EF6': 'Y',
'\u1EF4': 'Y',
'\u01B3': 'Y',
'\u024E': 'Y',
'\u1EFE': 'Y',
'\u24CF': 'Z',
'\uFF3A': 'Z',
'\u0179': 'Z',
'\u1E90': 'Z',
'\u017B': 'Z',
'\u017D': 'Z',
'\u1E92': 'Z',
'\u1E94': 'Z',
'\u01B5': 'Z',
'\u0224': 'Z',
'\u2C7F': 'Z',
'\u2C6B': 'Z',
'\uA762': 'Z',
'\u24D0': 'a',
'\uFF41': 'a',
'\u1E9A': 'a',
'\u00E0': 'a',
'\u00E1': 'a',
'\u00E2': 'a',
'\u1EA7': 'a',
'\u1EA5': 'a',
'\u1EAB': 'a',
'\u1EA9': 'a',
'\u00E3': 'a',
'\u0101': 'a',
'\u0103': 'a',
'\u1EB1': 'a',
'\u1EAF': 'a',
'\u1EB5': 'a',
'\u1EB3': 'a',
'\u0227': 'a',
'\u01E1': 'a',
'\u00E4': 'a',
'\u01DF': 'a',
'\u1EA3': 'a',
'\u00E5': 'a',
'\u01FB': 'a',
'\u01CE': 'a',
'\u0201': 'a',
'\u0203': 'a',
'\u1EA1': 'a',
'\u1EAD': 'a',
'\u1EB7': 'a',
'\u1E01': 'a',
'\u0105': 'a',
'\u2C65': 'a',
'\u0250': 'a',
'\uA733': 'aa',
'\u00E6': 'ae',
'\u01FD': 'ae',
'\u01E3': 'ae',
'\uA735': 'ao',
'\uA737': 'au',
'\uA739': 'av',
'\uA73B': 'av',
'\uA73D': 'ay',
'\u24D1': 'b',
'\uFF42': 'b',
'\u1E03': 'b',
'\u1E05': 'b',
'\u1E07': 'b',
'\u0180': 'b',
'\u0183': 'b',
'\u0253': 'b',
'\u24D2': 'c',
'\uFF43': 'c',
'\u0107': 'c',
'\u0109': 'c',
'\u010B': 'c',
'\u010D': 'c',
'\u00E7': 'c',
'\u1E09': 'c',
'\u0188': 'c',
'\u023C': 'c',
'\uA73F': 'c',
'\u2184': 'c',
'\u24D3': 'd',
'\uFF44': 'd',
'\u1E0B': 'd',
'\u010F': 'd',
'\u1E0D': 'd',
'\u1E11': 'd',
'\u1E13': 'd',
'\u1E0F': 'd',
'\u0111': 'd',
'\u018C': 'd',
'\u0256': 'd',
'\u0257': 'd',
'\uA77A': 'd',
'\u01F3': 'dz',
'\u01C6': 'dz',
'\u24D4': 'e',
'\uFF45': 'e',
'\u00E8': 'e',
'\u00E9': 'e',
'\u00EA': 'e',
'\u1EC1': 'e',
'\u1EBF': 'e',
'\u1EC5': 'e',
'\u1EC3': 'e',
'\u1EBD': 'e',
'\u0113': 'e',
'\u1E15': 'e',
'\u1E17': 'e',
'\u0115': 'e',
'\u0117': 'e',
'\u00EB': 'e',
'\u1EBB': 'e',
'\u011B': 'e',
'\u0205': 'e',
'\u0207': 'e',
'\u1EB9': 'e',
'\u1EC7': 'e',
'\u0229': 'e',
'\u1E1D': 'e',
'\u0119': 'e',
'\u1E19': 'e',
'\u1E1B': 'e',
'\u0247': 'e',
'\u025B': 'e',
'\u01DD': 'e',
'\u24D5': 'f',
'\uFF46': 'f',
'\u1E1F': 'f',
'\u0192': 'f',
'\uA77C': 'f',
'\u24D6': 'g',
'\uFF47': 'g',
'\u01F5': 'g',
'\u011D': 'g',
'\u1E21': 'g',
'\u011F': 'g',
'\u0121': 'g',
'\u01E7': 'g',
'\u0123': 'g',
'\u01E5': 'g',
'\u0260': 'g',
'\uA7A1': 'g',
'\u1D79': 'g',
'\uA77F': 'g',
'\u24D7': 'h',
'\uFF48': 'h',
'\u0125': 'h',
'\u1E23': 'h',
'\u1E27': 'h',
'\u021F': 'h',
'\u1E25': 'h',
'\u1E29': 'h',
'\u1E2B': 'h',
'\u1E96': 'h',
'\u0127': 'h',
'\u2C68': 'h',
'\u2C76': 'h',
'\u0265': 'h',
'\u0195': 'hv',
'\u24D8': 'i',
'\uFF49': 'i',
'\u00EC': 'i',
'\u00ED': 'i',
'\u00EE': 'i',
'\u0129': 'i',
'\u012B': 'i',
'\u012D': 'i',
'\u00EF': 'i',
'\u1E2F': 'i',
'\u1EC9': 'i',
'\u01D0': 'i',
'\u0209': 'i',
'\u020B': 'i',
'\u1ECB': 'i',
'\u012F': 'i',
'\u1E2D': 'i',
'\u0268': 'i',
'\u0131': 'i',
'\u24D9': 'j',
'\uFF4A': 'j',
'\u0135': 'j',
'\u01F0': 'j',
'\u0249': 'j',
'\u24DA': 'k',
'\uFF4B': 'k',
'\u1E31': 'k',
'\u01E9': 'k',
'\u1E33': 'k',
'\u0137': 'k',
'\u1E35': 'k',
'\u0199': 'k',
'\u2C6A': 'k',
'\uA741': 'k',
'\uA743': 'k',
'\uA745': 'k',
'\uA7A3': 'k',
'\u24DB': 'l',
'\uFF4C': 'l',
'\u0140': 'l',
'\u013A': 'l',
'\u013E': 'l',
'\u1E37': 'l',
'\u1E39': 'l',
'\u013C': 'l',
'\u1E3D': 'l',
'\u1E3B': 'l',
'\u017F': 'l',
'\u0142': 'l',
'\u019A': 'l',
'\u026B': 'l',
'\u2C61': 'l',
'\uA749': 'l',
'\uA781': 'l',
'\uA747': 'l',
'\u01C9': 'lj',
'\u24DC': 'm',
'\uFF4D': 'm',
'\u1E3F': 'm',
'\u1E41': 'm',
'\u1E43': 'm',
'\u0271': 'm',
'\u026F': 'm',
'\u24DD': 'n',
'\uFF4E': 'n',
'\u01F9': 'n',
'\u0144': 'n',
'\u00F1': 'n',
'\u1E45': 'n',
'\u0148': 'n',
'\u1E47': 'n',
'\u0146': 'n',
'\u1E4B': 'n',
'\u1E49': 'n',
'\u019E': 'n',
'\u0272': 'n',
'\u0149': 'n',
'\uA791': 'n',
'\uA7A5': 'n',
'\u01CC': 'nj',
'\u24DE': 'o',
'\uFF4F': 'o',
'\u00F2': 'o',
'\u00F3': 'o',
'\u00F4': 'o',
'\u1ED3': 'o',
'\u1ED1': 'o',
'\u1ED7': 'o',
'\u1ED5': 'o',
'\u00F5': 'o',
'\u1E4D': 'o',
'\u022D': 'o',
'\u1E4F': 'o',
'\u014D': 'o',
'\u1E51': 'o',
'\u1E53': 'o',
'\u014F': 'o',
'\u022F': 'o',
'\u0231': 'o',
'\u00F6': 'o',
'\u022B': 'o',
'\u1ECF': 'o',
'\u0151': 'o',
'\u01D2': 'o',
'\u020D': 'o',
'\u020F': 'o',
'\u01A1': 'o',
'\u1EDD': 'o',
'\u1EDB': 'o',
'\u1EE1': 'o',
'\u1EDF': 'o',
'\u1EE3': 'o',
'\u1ECD': 'o',
'\u1ED9': 'o',
'\u01EB': 'o',
'\u01ED': 'o',
'\u00F8': 'o',
'\u01FF': 'o',
'\u0254': 'o',
'\uA74B': 'o',
'\uA74D': 'o',
'\u0275': 'o',
'\u0153': 'oe',
'\u01A3': 'oi',
'\u0223': 'ou',
'\uA74F': 'oo',
'\u24DF': 'p',
'\uFF50': 'p',
'\u1E55': 'p',
'\u1E57': 'p',
'\u01A5': 'p',
'\u1D7D': 'p',
'\uA751': 'p',
'\uA753': 'p',
'\uA755': 'p',
'\u24E0': 'q',
'\uFF51': 'q',
'\u024B': 'q',
'\uA757': 'q',
'\uA759': 'q',
'\u24E1': 'r',
'\uFF52': 'r',
'\u0155': 'r',
'\u1E59': 'r',
'\u0159': 'r',
'\u0211': 'r',
'\u0213': 'r',
'\u1E5B': 'r',
'\u1E5D': 'r',
'\u0157': 'r',
'\u1E5F': 'r',
'\u024D': 'r',
'\u027D': 'r',
'\uA75B': 'r',
'\uA7A7': 'r',
'\uA783': 'r',
'\u24E2': 's',
'\uFF53': 's',
'\u00DF': 's',
'\u015B': 's',
'\u1E65': 's',
'\u015D': 's',
'\u1E61': 's',
'\u0161': 's',
'\u1E67': 's',
'\u1E63': 's',
'\u1E69': 's',
'\u0219': 's',
'\u015F': 's',
'\u023F': 's',
'\uA7A9': 's',
'\uA785': 's',
'\u1E9B': 's',
'\u24E3': 't',
'\uFF54': 't',
'\u1E6B': 't',
'\u1E97': 't',
'\u0165': 't',
'\u1E6D': 't',
'\u021B': 't',
'\u0163': 't',
'\u1E71': 't',
'\u1E6F': 't',
'\u0167': 't',
'\u01AD': 't',
'\u0288': 't',
'\u2C66': 't',
'\uA787': 't',
'\uA729': 'tz',
'\u24E4': 'u',
'\uFF55': 'u',
'\u00F9': 'u',
'\u00FA': 'u',
'\u00FB': 'u',
'\u0169': 'u',
'\u1E79': 'u',
'\u016B': 'u',
'\u1E7B': 'u',
'\u016D': 'u',
'\u00FC': 'u',
'\u01DC': 'u',
'\u01D8': 'u',
'\u01D6': 'u',
'\u01DA': 'u',
'\u1EE7': 'u',
'\u016F': 'u',
'\u0171': 'u',
'\u01D4': 'u',
'\u0215': 'u',
'\u0217': 'u',
'\u01B0': 'u',
'\u1EEB': 'u',
'\u1EE9': 'u',
'\u1EEF': 'u',
'\u1EED': 'u',
'\u1EF1': 'u',
'\u1EE5': 'u',
'\u1E73': 'u',
'\u0173': 'u',
'\u1E77': 'u',
'\u1E75': 'u',
'\u0289': 'u',
'\u24E5': 'v',
'\uFF56': 'v',
'\u1E7D': 'v',
'\u1E7F': 'v',
'\u028B': 'v',
'\uA75F': 'v',
'\u028C': 'v',
'\uA761': 'vy',
'\u24E6': 'w',
'\uFF57': 'w',
'\u1E81': 'w',
'\u1E83': 'w',
'\u0175': 'w',
'\u1E87': 'w',
'\u1E85': 'w',
'\u1E98': 'w',
'\u1E89': 'w',
'\u2C73': 'w',
'\u24E7': 'x',
'\uFF58': 'x',
'\u1E8B': 'x',
'\u1E8D': 'x',
'\u24E8': 'y',
'\uFF59': 'y',
'\u1EF3': 'y',
'\u00FD': 'y',
'\u0177': 'y',
'\u1EF9': 'y',
'\u0233': 'y',
'\u1E8F': 'y',
'\u00FF': 'y',
'\u1EF7': 'y',
'\u1E99': 'y',
'\u1EF5': 'y',
'\u01B4': 'y',
'\u024F': 'y',
'\u1EFF': 'y',
'\u24E9': 'z',
'\uFF5A': 'z',
'\u017A': 'z',
'\u1E91': 'z',
'\u017C': 'z',
'\u017E': 'z',
'\u1E93': 'z',
'\u1E95': 'z',
'\u01B6': 'z',
'\u0225': 'z',
'\u0240': 'z',
'\u2C6C': 'z',
'\uA763': 'z',
'\u0386': '\u0391',
'\u0388': '\u0395',
'\u0389': '\u0397',
'\u038A': '\u0399',
'\u03AA': '\u0399',
'\u038C': '\u039F',
'\u038E': '\u03A5',
'\u03AB': '\u03A5',
'\u038F': '\u03A9',
'\u03AC': '\u03B1',
'\u03AD': '\u03B5',
'\u03AE': '\u03B7',
'\u03AF': '\u03B9',
'\u03CA': '\u03B9',
'\u0390': '\u03B9',
'\u03CC': '\u03BF',
'\u03CD': '\u03C5',
'\u03CB': '\u03C5',
'\u03B0': '\u03C5',
'\u03CE': '\u03C9',
'\u03C2': '\u03C3',
'\u2019': '\''
};
return diacritics;
});
S2.define('select2/data/base',[
'../utils'
], function (Utils) {
function BaseAdapter ($element, options) {
BaseAdapter.__super__.constructor.call(this);
}
Utils.Extend(BaseAdapter, Utils.Observable);
BaseAdapter.prototype.current = function (callback) {
throw new Error('The `current` method must be defined in child classes.');
};
BaseAdapter.prototype.query = function (params, callback) {
throw new Error('The `query` method must be defined in child classes.');
};
BaseAdapter.prototype.bind = function (container, $container) {
// Can be implemented in subclasses
};
BaseAdapter.prototype.destroy = function () {
// Can be implemented in subclasses
};
BaseAdapter.prototype.generateResultId = function (container, data) {
var id = container.id + '-result-';
id += Utils.generateChars(4);
if (data.id != null) {
id += '-' + data.id.toString();
} else {
id += '-' + Utils.generateChars(4);
}
return id;
};
return BaseAdapter;
});
S2.define('select2/data/select',[
'./base',
'../utils',
'jquery'
], function (BaseAdapter, Utils, $) {
function SelectAdapter ($element, options) {
this.$element = $element;
this.options = options;
SelectAdapter.__super__.constructor.call(this);
}
Utils.Extend(SelectAdapter, BaseAdapter);
SelectAdapter.prototype.current = function (callback) {
var self = this;
var data = Array.prototype.map.call(
this.$element[0].querySelectorAll(':checked'),
function (selectedElement) {
return self.item($(selectedElement));
}
);
callback(data);
};
SelectAdapter.prototype.select = function (data) {
var self = this;
data.selected = true;
// If data.element is a DOM node, use it instead
if (
data.element != null && data.element.tagName.toLowerCase() === 'option'
) {
data.element.selected = true;
this.$element.trigger('input').trigger('change');
return;
}
if (this.$element.prop('multiple')) {
this.current(function (currentData) {
var val = [];
data = [data];
data.push.apply(data, currentData);
for (var d = 0; d < data.length; d++) {
var id = data[d].id;
if (val.indexOf(id) === -1) {
val.push(id);
}
}
self.$element.val(val);
self.$element.trigger('input').trigger('change');
});
} else {
var val = data.id;
this.$element.val(val);
this.$element.trigger('input').trigger('change');
}
};
SelectAdapter.prototype.unselect = function (data) {
var self = this;
if (!this.$element.prop('multiple')) {
return;
}
data.selected = false;
if (
data.element != null &&
data.element.tagName.toLowerCase() === 'option'
) {
data.element.selected = false;
this.$element.trigger('input').trigger('change');
return;
}
this.current(function (currentData) {
var val = [];
for (var d = 0; d < currentData.length; d++) {
var id = currentData[d].id;
if (id !== data.id && val.indexOf(id) === -1) {
val.push(id);
}
}
self.$element.val(val);
self.$element.trigger('input').trigger('change');
});
};
SelectAdapter.prototype.bind = function (container, $container) {
var self = this;
this.container = container;
container.on('select', function (params) {
self.select(params.data);
});
container.on('unselect', function (params) {
self.unselect(params.data);
});
};
SelectAdapter.prototype.destroy = function () {
// Remove anything added to child elements
this.$element.find('*').each(function () {
// Remove any custom data set by Select2
Utils.RemoveData(this);
});
};
SelectAdapter.prototype.query = function (params, callback) {
var data = [];
var self = this;
var $options = this.$element.children();
$options.each(function () {
if (
this.tagName.toLowerCase() !== 'option' &&
this.tagName.toLowerCase() !== 'optgroup'
) {
return;
}
var $option = $(this);
var option = self.item($option);
var matches = self.matches(params, option);
if (matches !== null) {
data.push(matches);
}
});
callback({
results: data
});
};
SelectAdapter.prototype.addOptions = function ($options) {
this.$element.append($options);
};
SelectAdapter.prototype.option = function (data) {
var option;
if (data.children) {
option = document.createElement('optgroup');
option.label = data.text;
} else {
option = document.createElement('option');
if (option.textContent !== undefined) {
option.textContent = data.text;
} else {
option.innerText = data.text;
}
}
if (data.id !== undefined) {
option.value = data.id;
}
if (data.disabled) {
option.disabled = true;
}
if (data.selected) {
option.selected = true;
}
if (data.title) {
option.title = data.title;
}
var normalizedData = this._normalizeItem(data);
normalizedData.element = option;
// Override the option's data with the combined data
Utils.StoreData(option, 'data', normalizedData);
return $(option);
};
SelectAdapter.prototype.item = function ($option) {
var data = {};
data = Utils.GetData($option[0], 'data');
if (data != null) {
return data;
}
var option = $option[0];
if (option.tagName.toLowerCase() === 'option') {
data = {
id: $option.val(),
text: $option.text(),
disabled: $option.prop('disabled'),
selected: $option.prop('selected'),
title: $option.prop('title')
};
} else if (option.tagName.toLowerCase() === 'optgroup') {
data = {
text: $option.prop('label'),
children: [],
title: $option.prop('title')
};
var $children = $option.children('option');
var children = [];
for (var c = 0; c < $children.length; c++) {
var $child = $($children[c]);
var child = this.item($child);
children.push(child);
}
data.children = children;
}
data = this._normalizeItem(data);
data.element = $option[0];
Utils.StoreData($option[0], 'data', data);
return data;
};
SelectAdapter.prototype._normalizeItem = function (item) {
if (item !== Object(item)) {
item = {
id: item,
text: item
};
}
item = $.extend({}, {
text: ''
}, item);
var defaults = {
selected: false,
disabled: false
};
if (item.id != null) {
item.id = item.id.toString();
}
if (item.text != null) {
item.text = item.text.toString();
}
if (item._resultId == null && item.id && this.container != null) {
item._resultId = this.generateResultId(this.container, item);
}
return $.extend({}, defaults, item);
};
SelectAdapter.prototype.matches = function (params, data) {
var matcher = this.options.get('matcher');
return matcher(params, data);
};
return SelectAdapter;
});
S2.define('select2/data/array',[
'./select',
'../utils',
'jquery'
], function (SelectAdapter, Utils, $) {
function ArrayAdapter ($element, options) {
this._dataToConvert = options.get('data') || [];
ArrayAdapter.__super__.constructor.call(this, $element, options);
}
Utils.Extend(ArrayAdapter, SelectAdapter);
ArrayAdapter.prototype.bind = function (container, $container) {
ArrayAdapter.__super__.bind.call(this, container, $container);
this.addOptions(this.convertToOptions(this._dataToConvert));
};
ArrayAdapter.prototype.select = function (data) {
var $option = this.$element.find('option').filter(function (i, elm) {
return elm.value == data.id.toString();
});
if ($option.length === 0) {
$option = this.option(data);
this.addOptions($option);
}
ArrayAdapter.__super__.select.call(this, data);
};
ArrayAdapter.prototype.convertToOptions = function (data) {
var self = this;
var $existing = this.$element.find('option');
var existingIds = $existing.map(function () {
return self.item($(this)).id;
}).get();
var $options = [];
// Filter out all items except for the one passed in the argument
function onlyItem (item) {
return function () {
return $(this).val() == item.id;
};
}
for (var d = 0; d < data.length; d++) {
var item = this._normalizeItem(data[d]);
// Skip items which were pre-loaded, only merge the data
if (existingIds.indexOf(item.id) >= 0) {
var $existingOption = $existing.filter(onlyItem(item));
var existingData = this.item($existingOption);
var newData = $.extend(true, {}, item, existingData);
var $newOption = this.option(newData);
$existingOption.replaceWith($newOption);
continue;
}
var $option = this.option(item);
if (item.children) {
var $children = this.convertToOptions(item.children);
$option.append($children);
}
$options.push($option);
}
return $options;
};
return ArrayAdapter;
});
S2.define('select2/data/ajax',[
'./array',
'../utils',
'jquery'
], function (ArrayAdapter, Utils, $) {
function AjaxAdapter ($element, options) {
this.ajaxOptions = this._applyDefaults(options.get('ajax'));
if (this.ajaxOptions.processResults != null) {
this.processResults = this.ajaxOptions.processResults;
}
AjaxAdapter.__super__.constructor.call(this, $element, options);
}
Utils.Extend(AjaxAdapter, ArrayAdapter);
AjaxAdapter.prototype._applyDefaults = function (options) {
var defaults = {
data: function (params) {
return $.extend({}, params, {
q: params.term
});
},
transport: function (params, success, failure) {
var $request = $.ajax(params);
$request.then(success);
$request.fail(failure);
return $request;
}
};
return $.extend({}, defaults, options, true);
};
AjaxAdapter.prototype.processResults = function (results) {
return results;
};
AjaxAdapter.prototype.query = function (params, callback) {
var matches = [];
var self = this;
if (this._request != null) {
// JSONP requests cannot always be aborted
if (typeof this._request.abort === 'function') {
this._request.abort();
}
this._request = null;
}
var options = $.extend({
type: 'GET'
}, this.ajaxOptions);
if (typeof options.url === 'function') {
options.url = options.url.call(this.$element, params);
}
if (typeof options.data === 'function') {
options.data = options.data.call(this.$element, params);
}
function request () {
var $request = options.transport(options, function (data) {
var results = self.processResults(data, params);
if (self.options.get('debug') && window.console && console.error) {
// Check to make sure that the response included a `results` key.
if (!results || !results.results || !Array.isArray(results.results)) {
console.error(
'Select2: The AJAX results did not return an array in the ' +
'`results` key of the response.'
);
}
}
callback(results);
}, function () {
// Attempt to detect if a request was aborted
// Only works if the transport exposes a status property
if ('status' in $request &&
($request.status === 0 || $request.status === '0')) {
return;
}
self.trigger('results:message', {
message: 'errorLoading'
});
});
self._request = $request;
}
if (this.ajaxOptions.delay && params.term != null) {
if (this._queryTimeout) {
window.clearTimeout(this._queryTimeout);
}
this._queryTimeout = window.setTimeout(request, this.ajaxOptions.delay);
} else {
request();
}
};
return AjaxAdapter;
});
S2.define('select2/data/tags',[
'jquery'
], function ($) {
function Tags (decorated, $element, options) {
var tags = options.get('tags');
var createTag = options.get('createTag');
if (createTag !== undefined) {
this.createTag = createTag;
}
var insertTag = options.get('insertTag');
if (insertTag !== undefined) {
this.insertTag = insertTag;
}
decorated.call(this, $element, options);
if (Array.isArray(tags)) {
for (var t = 0; t < tags.length; t++) {
var tag = tags[t];
var item = this._normalizeItem(tag);
var $option = this.option(item);
this.$element.append($option);
}
}
}
Tags.prototype.query = function (decorated, params, callback) {
var self = this;
this._removeOldTags();
if (params.term == null || params.page != null) {
decorated.call(this, params, callback);
return;
}
function wrapper (obj, child) {
var data = obj.results;
for (var i = 0; i < data.length; i++) {
var option = data[i];
var checkChildren = (
option.children != null &&
!wrapper({
results: option.children
}, true)
);
var optionText = (option.text || '').toUpperCase();
var paramsTerm = (params.term || '').toUpperCase();
var checkText = optionText === paramsTerm;
if (checkText || checkChildren) {
if (child) {
return false;
}
obj.data = data;
callback(obj);
return;
}
}
if (child) {
return true;
}
var tag = self.createTag(params);
if (tag != null) {
var $option = self.option(tag);
$option.attr('data-select2-tag', 'true');
self.addOptions([$option]);
self.insertTag(data, tag);
}
obj.results = data;
callback(obj);
}
decorated.call(this, params, wrapper);
};
Tags.prototype.createTag = function (decorated, params) {
if (params.term == null) {
return null;
}
var term = params.term.trim();
if (term === '') {
return null;
}
return {
id: term,
text: term
};
};
Tags.prototype.insertTag = function (_, data, tag) {
data.unshift(tag);
};
Tags.prototype._removeOldTags = function (_) {
var $options = this.$element.find('option[data-select2-tag]');
$options.each(function () {
if (this.selected) {
return;
}
$(this).remove();
});
};
return Tags;
});
S2.define('select2/data/tokenizer',[
'jquery'
], function ($) {
function Tokenizer (decorated, $element, options) {
var tokenizer = options.get('tokenizer');
if (tokenizer !== undefined) {
this.tokenizer = tokenizer;
}
decorated.call(this, $element, options);
}
Tokenizer.prototype.bind = function (decorated, container, $container) {
decorated.call(this, container, $container);
this.$search = container.dropdown.$search || container.selection.$search ||
$container.find('.select2-search__field');
};
Tokenizer.prototype.query = function (decorated, params, callback) {
var self = this;
function createAndSelect (data) {
// Normalize the data object so we can use it for checks
var item = self._normalizeItem(data);
// Check if the data object already exists as a tag
// Select it if it doesn't
var $existingOptions = self.$element.find('option').filter(function () {
return $(this).val() === item.id;
});
// If an existing option wasn't found for it, create the option
if (!$existingOptions.length) {
var $option = self.option(item);
$option.attr('data-select2-tag', true);
self._removeOldTags();
self.addOptions([$option]);
}
// Select the item, now that we know there is an option for it
select(item);
}
function select (data) {
self.trigger('select', {
data: data
});
}
params.term = params.term || '';
var tokenData = this.tokenizer(params, this.options, createAndSelect);
if (tokenData.term !== params.term) {
// Replace the search term if we have the search box
if (this.$search.length) {
this.$search.val(tokenData.term);
this.$search.trigger('focus');
}
params.term = tokenData.term;
}
decorated.call(this, params, callback);
};
Tokenizer.prototype.tokenizer = function (_, params, options, callback) {
var separators = options.get('tokenSeparators') || [];
var term = params.term;
var i = 0;
var createTag = this.createTag || function (params) {
return {
id: params.term,
text: params.term
};
};
while (i < term.length) {
var termChar = term[i];
if (separators.indexOf(termChar) === -1) {
i++;
continue;
}
var part = term.substr(0, i);
var partParams = $.extend({}, params, {
term: part
});
var data = createTag(partParams);
if (data == null) {
i++;
continue;
}
callback(data);
// Reset the term to not include the tokenized portion
term = term.substr(i + 1) || '';
i = 0;
}
return {
term: term
};
};
return Tokenizer;
});
S2.define('select2/data/minimumInputLength',[
], function () {
function MinimumInputLength (decorated, $e, options) {
this.minimumInputLength = options.get('minimumInputLength');
decorated.call(this, $e, options);
}
MinimumInputLength.prototype.query = function (decorated, params, callback) {
params.term = params.term || '';
if (params.term.length < this.minimumInputLength) {
this.trigger('results:message', {
message: 'inputTooShort',
args: {
minimum: this.minimumInputLength,
input: params.term,
params: params
}
});
return;
}
decorated.call(this, params, callback);
};
return MinimumInputLength;
});
S2.define('select2/data/maximumInputLength',[
], function () {
function MaximumInputLength (decorated, $e, options) {
this.maximumInputLength = options.get('maximumInputLength');
decorated.call(this, $e, options);
}
MaximumInputLength.prototype.query = function (decorated, params, callback) {
params.term = params.term || '';
if (this.maximumInputLength > 0 &&
params.term.length > this.maximumInputLength) {
this.trigger('results:message', {
message: 'inputTooLong',
args: {
maximum: this.maximumInputLength,
input: params.term,
params: params
}
});
return;
}
decorated.call(this, params, callback);
};
return MaximumInputLength;
});
S2.define('select2/data/maximumSelectionLength',[
], function (){
function MaximumSelectionLength (decorated, $e, options) {
this.maximumSelectionLength = options.get('maximumSelectionLength');
decorated.call(this, $e, options);
}
MaximumSelectionLength.prototype.bind =
function (decorated, container, $container) {
var self = this;
decorated.call(this, container, $container);
container.on('select', function () {
self._checkIfMaximumSelected();
});
};
MaximumSelectionLength.prototype.query =
function (decorated, params, callback) {
var self = this;
this._checkIfMaximumSelected(function () {
decorated.call(self, params, callback);
});
};
MaximumSelectionLength.prototype._checkIfMaximumSelected =
function (_, successCallback) {
var self = this;
this.current(function (currentData) {
var count = currentData != null ? currentData.length : 0;
if (self.maximumSelectionLength > 0 &&
count >= self.maximumSelectionLength) {
self.trigger('results:message', {
message: 'maximumSelected',
args: {
maximum: self.maximumSelectionLength
}
});
return;
}
if (successCallback) {
successCallback();
}
});
};
return MaximumSelectionLength;
});
S2.define('select2/dropdown',[
'jquery',
'./utils'
], function ($, Utils) {
function Dropdown ($element, options) {
this.$element = $element;
this.options = options;
Dropdown.__super__.constructor.call(this);
}
Utils.Extend(Dropdown, Utils.Observable);
Dropdown.prototype.render = function () {
var $dropdown = $(
'' +
'' +
''
);
$dropdown.attr('dir', this.options.get('dir'));
this.$dropdown = $dropdown;
return $dropdown;
};
Dropdown.prototype.bind = function () {
// Should be implemented in subclasses
};
Dropdown.prototype.position = function ($dropdown, $container) {
// Should be implemented in subclasses
};
Dropdown.prototype.destroy = function () {
// Remove the dropdown from the DOM
this.$dropdown.remove();
};
return Dropdown;
});
S2.define('select2/dropdown/search',[
'jquery'
], function ($) {
function Search () { }
Search.prototype.render = function (decorated) {
var $rendered = decorated.call(this);
var searchLabel = this.options.get('translations').get('search');
var $search = $(
'' +
'' +
''
);
this.$searchContainer = $search;
this.$search = $search.find('input');
this.$search.prop('autocomplete', this.options.get('autocomplete'));
this.$search.attr('aria-label', searchLabel());
$rendered.prepend($search);
return $rendered;
};
Search.prototype.bind = function (decorated, container, $container) {
var self = this;
var resultsId = container.id + '-results';
decorated.call(this, container, $container);
this.$search.on('keydown', function (evt) {
self.trigger('keypress', evt);
self._keyUpPrevented = evt.isDefaultPrevented();
});
// Workaround for browsers which do not support the `input` event
// This will prevent double-triggering of events for browsers which support
// both the `keyup` and `input` events.
this.$search.on('input', function (evt) {
// Unbind the duplicated `keyup` event
$(this).off('keyup');
});
this.$search.on('keyup input', function (evt) {
self.handleSearch(evt);
});
container.on('open', function () {
self.$search.attr('tabindex', 0);
self.$search.attr('aria-controls', resultsId);
self.$search.trigger('focus');
window.setTimeout(function () {
self.$search.trigger('focus');
}, 0);
});
container.on('close', function () {
self.$search.attr('tabindex', -1);
self.$search.removeAttr('aria-controls');
self.$search.removeAttr('aria-activedescendant');
self.$search.val('');
self.$search.trigger('blur');
});
container.on('focus', function () {
if (!container.isOpen()) {
self.$search.trigger('focus');
}
});
container.on('results:all', function (params) {
if (params.query.term == null || params.query.term === '') {
var showSearch = self.showSearch(params);
if (showSearch) {
self.$searchContainer[0].classList.remove('select2-search--hide');
} else {
self.$searchContainer[0].classList.add('select2-search--hide');
}
}
});
container.on('results:focus', function (params) {
if (params.data._resultId) {
self.$search.attr('aria-activedescendant', params.data._resultId);
} else {
self.$search.removeAttr('aria-activedescendant');
}
});
};
Search.prototype.handleSearch = function (evt) {
if (!this._keyUpPrevented) {
var input = this.$search.val();
this.trigger('query', {
term: input
});
}
this._keyUpPrevented = false;
};
Search.prototype.showSearch = function (_, params) {
return true;
};
return Search;
});
S2.define('select2/dropdown/hidePlaceholder',[
], function () {
function HidePlaceholder (decorated, $element, options, dataAdapter) {
this.placeholder = this.normalizePlaceholder(options.get('placeholder'));
decorated.call(this, $element, options, dataAdapter);
}
HidePlaceholder.prototype.append = function (decorated, data) {
data.results = this.removePlaceholder(data.results);
decorated.call(this, data);
};
HidePlaceholder.prototype.normalizePlaceholder = function (_, placeholder) {
if (typeof placeholder === 'string') {
placeholder = {
id: '',
text: placeholder
};
}
return placeholder;
};
HidePlaceholder.prototype.removePlaceholder = function (_, data) {
var modifiedData = data.slice(0);
for (var d = data.length - 1; d >= 0; d--) {
var item = data[d];
if (this.placeholder.id === item.id) {
modifiedData.splice(d, 1);
}
}
return modifiedData;
};
return HidePlaceholder;
});
S2.define('select2/dropdown/infiniteScroll',[
'jquery'
], function ($) {
function InfiniteScroll (decorated, $element, options, dataAdapter) {
this.lastParams = {};
decorated.call(this, $element, options, dataAdapter);
this.$loadingMore = this.createLoadingMore();
this.loading = false;
}
InfiniteScroll.prototype.append = function (decorated, data) {
this.$loadingMore.remove();
this.loading = false;
decorated.call(this, data);
if (this.showLoadingMore(data)) {
this.$results.append(this.$loadingMore);
this.loadMoreIfNeeded();
}
};
InfiniteScroll.prototype.bind = function (decorated, container, $container) {
var self = this;
decorated.call(this, container, $container);
container.on('query', function (params) {
self.lastParams = params;
self.loading = true;
});
container.on('query:append', function (params) {
self.lastParams = params;
self.loading = true;
});
this.$results.on('scroll', this.loadMoreIfNeeded.bind(this));
};
InfiniteScroll.prototype.loadMoreIfNeeded = function () {
var isLoadMoreVisible = $.contains(
document.documentElement,
this.$loadingMore[0]
);
if (this.loading || !isLoadMoreVisible) {
return;
}
var currentOffset = this.$results.offset().top +
this.$results.outerHeight(false);
var loadingMoreOffset = this.$loadingMore.offset().top +
this.$loadingMore.outerHeight(false);
if (currentOffset + 50 >= loadingMoreOffset) {
this.loadMore();
}
};
InfiniteScroll.prototype.loadMore = function () {
this.loading = true;
var params = $.extend({}, {page: 1}, this.lastParams);
params.page++;
this.trigger('query:append', params);
};
InfiniteScroll.prototype.showLoadingMore = function (_, data) {
return data.pagination && data.pagination.more;
};
InfiniteScroll.prototype.createLoadingMore = function () {
var $option = $(
''
);
var message = this.options.get('translations').get('loadingMore');
$option.html(message(this.lastParams));
return $option;
};
return InfiniteScroll;
});
S2.define('select2/dropdown/attachBody',[
'jquery',
'../utils'
], function ($, Utils) {
function AttachBody (decorated, $element, options) {
this.$dropdownParent = $(options.get('dropdownParent') || document.body);
decorated.call(this, $element, options);
}
AttachBody.prototype.bind = function (decorated, container, $container) {
var self = this;
decorated.call(this, container, $container);
container.on('open', function () {
self._showDropdown();
self._attachPositioningHandler(container);
// Must bind after the results handlers to ensure correct sizing
self._bindContainerResultHandlers(container);
});
container.on('close', function () {
self._hideDropdown();
self._detachPositioningHandler(container);
});
this.$dropdownContainer.on('mousedown', function (evt) {
evt.stopPropagation();
});
};
AttachBody.prototype.destroy = function (decorated) {
decorated.call(this);
this.$dropdownContainer.remove();
};
AttachBody.prototype.position = function (decorated, $dropdown, $container) {
// Clone all of the container classes
$dropdown.attr('class', $container.attr('class'));
$dropdown[0].classList.remove('select2');
$dropdown[0].classList.add('select2-container--open');
$dropdown.css({
position: 'absolute',
top: -999999
});
this.$container = $container;
};
AttachBody.prototype.render = function (decorated) {
var $container = $('');
var $dropdown = decorated.call(this);
$container.append($dropdown);
this.$dropdownContainer = $container;
return $container;
};
AttachBody.prototype._hideDropdown = function (decorated) {
this.$dropdownContainer.detach();
};
AttachBody.prototype._bindContainerResultHandlers =
function (decorated, container) {
// These should only be bound once
if (this._containerResultsHandlersBound) {
return;
}
var self = this;
container.on('results:all', function () {
self._positionDropdown();
self._resizeDropdown();
});
container.on('results:append', function () {
self._positionDropdown();
self._resizeDropdown();
});
container.on('results:message', function () {
self._positionDropdown();
self._resizeDropdown();
});
container.on('select', function () {
self._positionDropdown();
self._resizeDropdown();
});
container.on('unselect', function () {
self._positionDropdown();
self._resizeDropdown();
});
this._containerResultsHandlersBound = true;
};
AttachBody.prototype._attachPositioningHandler =
function (decorated, container) {
var self = this;
var scrollEvent = 'scroll.select2.' + container.id;
var resizeEvent = 'resize.select2.' + container.id;
var orientationEvent = 'orientationchange.select2.' + container.id;
var $watchers = this.$container.parents().filter(Utils.hasScroll);
$watchers.each(function () {
Utils.StoreData(this, 'select2-scroll-position', {
x: $(this).scrollLeft(),
y: $(this).scrollTop()
});
});
$watchers.on(scrollEvent, function (ev) {
var position = Utils.GetData(this, 'select2-scroll-position');
$(this).scrollTop(position.y);
});
$(window).on(scrollEvent + ' ' + resizeEvent + ' ' + orientationEvent,
function (e) {
self._positionDropdown();
self._resizeDropdown();
});
};
AttachBody.prototype._detachPositioningHandler =
function (decorated, container) {
var scrollEvent = 'scroll.select2.' + container.id;
var resizeEvent = 'resize.select2.' + container.id;
var orientationEvent = 'orientationchange.select2.' + container.id;
var $watchers = this.$container.parents().filter(Utils.hasScroll);
$watchers.off(scrollEvent);
$(window).off(scrollEvent + ' ' + resizeEvent + ' ' + orientationEvent);
};
AttachBody.prototype._positionDropdown = function () {
var $window = $(window);
var isCurrentlyAbove = this.$dropdown[0].classList
.contains('select2-dropdown--above');
var isCurrentlyBelow = this.$dropdown[0].classList
.contains('select2-dropdown--below');
var newDirection = null;
var offset = this.$container.offset();
offset.bottom = offset.top + this.$container.outerHeight(false);
var container = {
height: this.$container.outerHeight(false)
};
container.top = offset.top;
container.bottom = offset.top + container.height;
var dropdown = {
height: this.$dropdown.outerHeight(false)
};
var viewport = {
top: $window.scrollTop(),
bottom: $window.scrollTop() + $window.height()
};
var enoughRoomAbove = viewport.top < (offset.top - dropdown.height);
var enoughRoomBelow = viewport.bottom > (offset.bottom + dropdown.height);
var css = {
left: offset.left,
top: container.bottom
};
// Determine what the parent element is to use for calculating the offset
var $offsetParent = this.$dropdownParent;
// For statically positioned elements, we need to get the element
// that is determining the offset
if ($offsetParent.css('position') === 'static') {
$offsetParent = $offsetParent.offsetParent();
}
var parentOffset = {
top: 0,
left: 0
};
if (
$.contains(document.body, $offsetParent[0]) ||
$offsetParent[0].isConnected
) {
parentOffset = $offsetParent.offset();
}
css.top -= parentOffset.top;
css.left -= parentOffset.left;
if (!isCurrentlyAbove && !isCurrentlyBelow) {
newDirection = 'below';
}
if (!enoughRoomBelow && enoughRoomAbove && !isCurrentlyAbove) {
newDirection = 'above';
} else if (!enoughRoomAbove && enoughRoomBelow && isCurrentlyAbove) {
newDirection = 'below';
}
if (newDirection == 'above' ||
(isCurrentlyAbove && newDirection !== 'below')) {
css.top = container.top - parentOffset.top - dropdown.height;
}
if (newDirection != null) {
this.$dropdown[0].classList.remove('select2-dropdown--below');
this.$dropdown[0].classList.remove('select2-dropdown--above');
this.$dropdown[0].classList.add('select2-dropdown--' + newDirection);
this.$container[0].classList.remove('select2-container--below');
this.$container[0].classList.remove('select2-container--above');
this.$container[0].classList.add('select2-container--' + newDirection);
}
this.$dropdownContainer.css(css);
};
AttachBody.prototype._resizeDropdown = function () {
var css = {
width: this.$container.outerWidth(false) + 'px'
};
if (this.options.get('dropdownAutoWidth')) {
css.minWidth = css.width;
css.position = 'relative';
css.width = 'auto';
}
this.$dropdown.css(css);
};
AttachBody.prototype._showDropdown = function (decorated) {
this.$dropdownContainer.appendTo(this.$dropdownParent);
this._positionDropdown();
this._resizeDropdown();
};
return AttachBody;
});
S2.define('select2/dropdown/minimumResultsForSearch',[
], function () {
function countResults (data) {
var count = 0;
for (var d = 0; d < data.length; d++) {
var item = data[d];
if (item.children) {
count += countResults(item.children);
} else {
count++;
}
}
return count;
}
function MinimumResultsForSearch (decorated, $element, options, dataAdapter) {
this.minimumResultsForSearch = options.get('minimumResultsForSearch');
if (this.minimumResultsForSearch < 0) {
this.minimumResultsForSearch = Infinity;
}
decorated.call(this, $element, options, dataAdapter);
}
MinimumResultsForSearch.prototype.showSearch = function (decorated, params) {
if (countResults(params.data.results) < this.minimumResultsForSearch) {
return false;
}
return decorated.call(this, params);
};
return MinimumResultsForSearch;
});
S2.define('select2/dropdown/selectOnClose',[
'../utils'
], function (Utils) {
function SelectOnClose () { }
SelectOnClose.prototype.bind = function (decorated, container, $container) {
var self = this;
decorated.call(this, container, $container);
container.on('close', function (params) {
self._handleSelectOnClose(params);
});
};
SelectOnClose.prototype._handleSelectOnClose = function (_, params) {
if (params && params.originalSelect2Event != null) {
var event = params.originalSelect2Event;
// Don't select an item if the close event was triggered from a select or
// unselect event
if (event._type === 'select' || event._type === 'unselect') {
return;
}
}
var $highlightedResults = this.getHighlightedResults();
// Only select highlighted results
if ($highlightedResults.length < 1) {
return;
}
var data = Utils.GetData($highlightedResults[0], 'data');
// Don't re-select already selected resulte
if (
(data.element != null && data.element.selected) ||
(data.element == null && data.selected)
) {
return;
}
this.trigger('select', {
data: data
});
};
return SelectOnClose;
});
S2.define('select2/dropdown/closeOnSelect',[
], function () {
function CloseOnSelect () { }
CloseOnSelect.prototype.bind = function (decorated, container, $container) {
var self = this;
decorated.call(this, container, $container);
container.on('select', function (evt) {
self._selectTriggered(evt);
});
container.on('unselect', function (evt) {
self._selectTriggered(evt);
});
};
CloseOnSelect.prototype._selectTriggered = function (_, evt) {
var originalEvent = evt.originalEvent;
// Don't close if the control key is being held
if (originalEvent && (originalEvent.ctrlKey || originalEvent.metaKey)) {
return;
}
this.trigger('close', {
originalEvent: originalEvent,
originalSelect2Event: evt
});
};
return CloseOnSelect;
});
S2.define('select2/dropdown/dropdownCss',[
'../utils'
], function (Utils) {
function DropdownCSS () { }
DropdownCSS.prototype.render = function (decorated) {
var $dropdown = decorated.call(this);
var dropdownCssClass = this.options.get('dropdownCssClass') || '';
if (dropdownCssClass.indexOf(':all:') !== -1) {
dropdownCssClass = dropdownCssClass.replace(':all:', '');
Utils.copyNonInternalCssClasses($dropdown[0], this.$element[0]);
}
$dropdown.addClass(dropdownCssClass);
return $dropdown;
};
return DropdownCSS;
});
S2.define('select2/dropdown/tagsSearchHighlight',[
'../utils'
], function (Utils) {
function TagsSearchHighlight () { }
TagsSearchHighlight.prototype.highlightFirstItem = function (decorated) {
var $options = this.$results
.find(
'.select2-results__option--selectable' +
':not(.select2-results__option--selected)'
);
if ($options.length > 0) {
var $firstOption = $options.first();
var data = Utils.GetData($firstOption[0], 'data');
var firstElement = data.element;
if (firstElement && firstElement.getAttribute) {
if (firstElement.getAttribute('data-select2-tag') === 'true') {
$firstOption.trigger('mouseenter');
return;
}
}
}
decorated.call(this);
};
return TagsSearchHighlight;
});
S2.define('select2/i18n/en',[],function () {
// English
return {
errorLoading: function () {
return 'The results could not be loaded.';
},
inputTooLong: function (args) {
var overChars = args.input.length - args.maximum;
var message = 'Please delete ' + overChars + ' character';
if (overChars != 1) {
message += 's';
}
return message;
},
inputTooShort: function (args) {
var remainingChars = args.minimum - args.input.length;
var message = 'Please enter ' + remainingChars + ' or more characters';
return message;
},
loadingMore: function () {
return 'Loading more results…';
},
maximumSelected: function (args) {
var message = 'You can only select ' + args.maximum + ' item';
if (args.maximum != 1) {
message += 's';
}
return message;
},
noResults: function () {
return 'No results found';
},
searching: function () {
return 'Searching…';
},
removeAllItems: function () {
return 'Remove all items';
},
removeItem: function () {
return 'Remove item';
},
search: function() {
return 'Search';
}
};
});
S2.define('select2/defaults',[
'jquery',
'./results',
'./selection/single',
'./selection/multiple',
'./selection/placeholder',
'./selection/allowClear',
'./selection/search',
'./selection/selectionCss',
'./selection/eventRelay',
'./utils',
'./translation',
'./diacritics',
'./data/select',
'./data/array',
'./data/ajax',
'./data/tags',
'./data/tokenizer',
'./data/minimumInputLength',
'./data/maximumInputLength',
'./data/maximumSelectionLength',
'./dropdown',
'./dropdown/search',
'./dropdown/hidePlaceholder',
'./dropdown/infiniteScroll',
'./dropdown/attachBody',
'./dropdown/minimumResultsForSearch',
'./dropdown/selectOnClose',
'./dropdown/closeOnSelect',
'./dropdown/dropdownCss',
'./dropdown/tagsSearchHighlight',
'./i18n/en'
], function ($,
ResultsList,
SingleSelection, MultipleSelection, Placeholder, AllowClear,
SelectionSearch, SelectionCSS, EventRelay,
Utils, Translation, DIACRITICS,
SelectData, ArrayData, AjaxData, Tags, Tokenizer,
MinimumInputLength, MaximumInputLength, MaximumSelectionLength,
Dropdown, DropdownSearch, HidePlaceholder, InfiniteScroll,
AttachBody, MinimumResultsForSearch, SelectOnClose, CloseOnSelect,
DropdownCSS, TagsSearchHighlight,
EnglishTranslation) {
function Defaults () {
this.reset();
}
Defaults.prototype.apply = function (options) {
options = $.extend(true, {}, this.defaults, options);
if (options.dataAdapter == null) {
if (options.ajax != null) {
options.dataAdapter = AjaxData;
} else if (options.data != null) {
options.dataAdapter = ArrayData;
} else {
options.dataAdapter = SelectData;
}
if (options.minimumInputLength > 0) {
options.dataAdapter = Utils.Decorate(
options.dataAdapter,
MinimumInputLength
);
}
if (options.maximumInputLength > 0) {
options.dataAdapter = Utils.Decorate(
options.dataAdapter,
MaximumInputLength
);
}
if (options.maximumSelectionLength > 0) {
options.dataAdapter = Utils.Decorate(
options.dataAdapter,
MaximumSelectionLength
);
}
if (options.tags) {
options.dataAdapter = Utils.Decorate(options.dataAdapter, Tags);
}
if (options.tokenSeparators != null || options.tokenizer != null) {
options.dataAdapter = Utils.Decorate(
options.dataAdapter,
Tokenizer
);
}
}
if (options.resultsAdapter == null) {
options.resultsAdapter = ResultsList;
if (options.ajax != null) {
options.resultsAdapter = Utils.Decorate(
options.resultsAdapter,
InfiniteScroll
);
}
if (options.placeholder != null) {
options.resultsAdapter = Utils.Decorate(
options.resultsAdapter,
HidePlaceholder
);
}
if (options.selectOnClose) {
options.resultsAdapter = Utils.Decorate(
options.resultsAdapter,
SelectOnClose
);
}
if (options.tags) {
options.resultsAdapter = Utils.Decorate(
options.resultsAdapter,
TagsSearchHighlight
);
}
}
if (options.dropdownAdapter == null) {
if (options.multiple) {
options.dropdownAdapter = Dropdown;
} else {
var SearchableDropdown = Utils.Decorate(Dropdown, DropdownSearch);
options.dropdownAdapter = SearchableDropdown;
}
if (options.minimumResultsForSearch !== 0) {
options.dropdownAdapter = Utils.Decorate(
options.dropdownAdapter,
MinimumResultsForSearch
);
}
if (options.closeOnSelect) {
options.dropdownAdapter = Utils.Decorate(
options.dropdownAdapter,
CloseOnSelect
);
}
if (options.dropdownCssClass != null) {
options.dropdownAdapter = Utils.Decorate(
options.dropdownAdapter,
DropdownCSS
);
}
options.dropdownAdapter = Utils.Decorate(
options.dropdownAdapter,
AttachBody
);
}
if (options.selectionAdapter == null) {
if (options.multiple) {
options.selectionAdapter = MultipleSelection;
} else {
options.selectionAdapter = SingleSelection;
}
// Add the placeholder mixin if a placeholder was specified
if (options.placeholder != null) {
options.selectionAdapter = Utils.Decorate(
options.selectionAdapter,
Placeholder
);
}
if (options.allowClear) {
options.selectionAdapter = Utils.Decorate(
options.selectionAdapter,
AllowClear
);
}
if (options.multiple) {
options.selectionAdapter = Utils.Decorate(
options.selectionAdapter,
SelectionSearch
);
}
if (options.selectionCssClass != null) {
options.selectionAdapter = Utils.Decorate(
options.selectionAdapter,
SelectionCSS
);
}
options.selectionAdapter = Utils.Decorate(
options.selectionAdapter,
EventRelay
);
}
// If the defaults were not previously applied from an element, it is
// possible for the language option to have not been resolved
options.language = this._resolveLanguage(options.language);
// Always fall back to English since it will always be complete
options.language.push('en');
var uniqueLanguages = [];
for (var l = 0; l < options.language.length; l++) {
var language = options.language[l];
if (uniqueLanguages.indexOf(language) === -1) {
uniqueLanguages.push(language);
}
}
options.language = uniqueLanguages;
options.translations = this._processTranslations(
options.language,
options.debug
);
return options;
};
Defaults.prototype.reset = function () {
function stripDiacritics (text) {
// Used 'uni range + named function' from http://jsperf.com/diacritics/18
function match(a) {
return DIACRITICS[a] || a;
}
return text.replace(/[^\u0000-\u007E]/g, match);
}
function matcher (params, data) {
// Always return the object if there is nothing to compare
if (params.term == null || params.term.trim() === '') {
return data;
}
// Do a recursive check for options with children
if (data.children && data.children.length > 0) {
// Clone the data object if there are children
// This is required as we modify the object to remove any non-matches
var match = $.extend(true, {}, data);
// Check each child of the option
for (var c = data.children.length - 1; c >= 0; c--) {
var child = data.children[c];
var matches = matcher(params, child);
// If there wasn't a match, remove the object in the array
if (matches == null) {
match.children.splice(c, 1);
}
}
// If any children matched, return the new object
if (match.children.length > 0) {
return match;
}
// If there were no matching children, check just the plain object
return matcher(params, match);
}
var original = stripDiacritics(data.text).toUpperCase();
var term = stripDiacritics(params.term).toUpperCase();
// Check if the text contains the term
if (original.indexOf(term) > -1) {
return data;
}
// If it doesn't contain the term, don't return anything
return null;
}
this.defaults = {
amdLanguageBase: './i18n/',
autocomplete: 'off',
closeOnSelect: true,
debug: false,
dropdownAutoWidth: false,
escapeMarkup: Utils.escapeMarkup,
language: {},
matcher: matcher,
minimumInputLength: 0,
maximumInputLength: 0,
maximumSelectionLength: 0,
minimumResultsForSearch: 0,
selectOnClose: false,
scrollAfterSelect: false,
sorter: function (data) {
return data;
},
templateResult: function (result) {
return result.text;
},
templateSelection: function (selection) {
return selection.text;
},
theme: 'default',
width: 'resolve'
};
};
Defaults.prototype.applyFromElement = function (options, $element) {
var optionLanguage = options.language;
var defaultLanguage = this.defaults.language;
var elementLanguage = $element.prop('lang');
var parentLanguage = $element.closest('[lang]').prop('lang');
var languages = Array.prototype.concat.call(
this._resolveLanguage(elementLanguage),
this._resolveLanguage(optionLanguage),
this._resolveLanguage(defaultLanguage),
this._resolveLanguage(parentLanguage)
);
options.language = languages;
return options;
};
Defaults.prototype._resolveLanguage = function (language) {
if (!language) {
return [];
}
if ($.isEmptyObject(language)) {
return [];
}
if ($.isPlainObject(language)) {
return [language];
}
var languages;
if (!Array.isArray(language)) {
languages = [language];
} else {
languages = language;
}
var resolvedLanguages = [];
for (var l = 0; l < languages.length; l++) {
resolvedLanguages.push(languages[l]);
if (typeof languages[l] === 'string' && languages[l].indexOf('-') > 0) {
// Extract the region information if it is included
var languageParts = languages[l].split('-');
var baseLanguage = languageParts[0];
resolvedLanguages.push(baseLanguage);
}
}
return resolvedLanguages;
};
Defaults.prototype._processTranslations = function (languages, debug) {
var translations = new Translation();
for (var l = 0; l < languages.length; l++) {
var languageData = new Translation();
var language = languages[l];
if (typeof language === 'string') {
try {
// Try to load it with the original name
languageData = Translation.loadPath(language);
} catch (e) {
try {
// If we couldn't load it, check if it wasn't the full path
language = this.defaults.amdLanguageBase + language;
languageData = Translation.loadPath(language);
} catch (ex) {
// The translation could not be loaded at all. Sometimes this is
// because of a configuration problem, other times this can be
// because of how Select2 helps load all possible translation files
if (debug && window.console && console.warn) {
console.warn(
'Select2: The language file for "' + language + '" could ' +
'not be automatically loaded. A fallback will be used instead.'
);
}
}
}
} else if ($.isPlainObject(language)) {
languageData = new Translation(language);
} else {
languageData = language;
}
translations.extend(languageData);
}
return translations;
};
Defaults.prototype.set = function (key, value) {
var camelKey = $.camelCase(key);
var data = {};
data[camelKey] = value;
var convertedData = Utils._convertData(data);
$.extend(true, this.defaults, convertedData);
};
var defaults = new Defaults();
return defaults;
});
S2.define('select2/options',[
'jquery',
'./defaults',
'./utils'
], function ($, Defaults, Utils) {
function Options (options, $element) {
this.options = options;
if ($element != null) {
this.fromElement($element);
}
if ($element != null) {
this.options = Defaults.applyFromElement(this.options, $element);
}
this.options = Defaults.apply(this.options);
}
Options.prototype.fromElement = function ($e) {
var excludedData = ['select2'];
if (this.options.multiple == null) {
this.options.multiple = $e.prop('multiple');
}
if (this.options.disabled == null) {
this.options.disabled = $e.prop('disabled');
}
if (this.options.autocomplete == null && $e.prop('autocomplete')) {
this.options.autocomplete = $e.prop('autocomplete');
}
if (this.options.dir == null) {
if ($e.prop('dir')) {
this.options.dir = $e.prop('dir');
} else if ($e.closest('[dir]').prop('dir')) {
this.options.dir = $e.closest('[dir]').prop('dir');
} else {
this.options.dir = 'ltr';
}
}
$e.prop('disabled', this.options.disabled);
$e.prop('multiple', this.options.multiple);
if (Utils.GetData($e[0], 'select2Tags')) {
if (this.options.debug && window.console && console.warn) {
console.warn(
'Select2: The `data-select2-tags` attribute has been changed to ' +
'use the `data-data` and `data-tags="true"` attributes and will be ' +
'removed in future versions of Select2.'
);
}
Utils.StoreData($e[0], 'data', Utils.GetData($e[0], 'select2Tags'));
Utils.StoreData($e[0], 'tags', true);
}
if (Utils.GetData($e[0], 'ajaxUrl')) {
if (this.options.debug && window.console && console.warn) {
console.warn(
'Select2: The `data-ajax-url` attribute has been changed to ' +
'`data-ajax--url` and support for the old attribute will be removed' +
' in future versions of Select2.'
);
}
$e.attr('ajax--url', Utils.GetData($e[0], 'ajaxUrl'));
Utils.StoreData($e[0], 'ajax-Url', Utils.GetData($e[0], 'ajaxUrl'));
}
var dataset = {};
function upperCaseLetter(_, letter) {
return letter.toUpperCase();
}
// Pre-load all of the attributes which are prefixed with `data-`
for (var attr = 0; attr < $e[0].attributes.length; attr++) {
var attributeName = $e[0].attributes[attr].name;
var prefix = 'data-';
if (attributeName.substr(0, prefix.length) == prefix) {
// Get the contents of the attribute after `data-`
var dataName = attributeName.substring(prefix.length);
// Get the data contents from the consistent source
// This is more than likely the jQuery data helper
var dataValue = Utils.GetData($e[0], dataName);
// camelCase the attribute name to match the spec
var camelDataName = dataName.replace(/-([a-z])/g, upperCaseLetter);
// Store the data attribute contents into the dataset since
dataset[camelDataName] = dataValue;
}
}
// Prefer the element's `dataset` attribute if it exists
// jQuery 1.x does not correctly handle data attributes with multiple dashes
if ($.fn.jquery && $.fn.jquery.substr(0, 2) == '1.' && $e[0].dataset) {
dataset = $.extend(true, {}, $e[0].dataset, dataset);
}
// Prefer our internal data cache if it exists
var data = $.extend(true, {}, Utils.GetData($e[0]), dataset);
data = Utils._convertData(data);
for (var key in data) {
if (excludedData.indexOf(key) > -1) {
continue;
}
if ($.isPlainObject(this.options[key])) {
$.extend(this.options[key], data[key]);
} else {
this.options[key] = data[key];
}
}
return this;
};
Options.prototype.get = function (key) {
return this.options[key];
};
Options.prototype.set = function (key, val) {
this.options[key] = val;
};
return Options;
});
S2.define('select2/core',[
'jquery',
'./options',
'./utils',
'./keys'
], function ($, Options, Utils, KEYS) {
var Select2 = function ($element, options) {
if (Utils.GetData($element[0], 'select2') != null) {
Utils.GetData($element[0], 'select2').destroy();
}
this.$element = $element;
this.id = this._generateId($element);
options = options || {};
this.options = new Options(options, $element);
Select2.__super__.constructor.call(this);
// Set up the tabindex
var tabindex = $element.attr('tabindex') || 0;
Utils.StoreData($element[0], 'old-tabindex', tabindex);
$element.attr('tabindex', '-1');
// Set up containers and adapters
var DataAdapter = this.options.get('dataAdapter');
this.dataAdapter = new DataAdapter($element, this.options);
var $container = this.render();
this._placeContainer($container);
var SelectionAdapter = this.options.get('selectionAdapter');
this.selection = new SelectionAdapter($element, this.options);
this.$selection = this.selection.render();
this.selection.position(this.$selection, $container);
var DropdownAdapter = this.options.get('dropdownAdapter');
this.dropdown = new DropdownAdapter($element, this.options);
this.$dropdown = this.dropdown.render();
this.dropdown.position(this.$dropdown, $container);
var ResultsAdapter = this.options.get('resultsAdapter');
this.results = new ResultsAdapter($element, this.options, this.dataAdapter);
this.$results = this.results.render();
this.results.position(this.$results, this.$dropdown);
// Bind events
var self = this;
// Bind the container to all of the adapters
this._bindAdapters();
// Register any DOM event handlers
this._registerDomEvents();
// Register any internal event handlers
this._registerDataEvents();
this._registerSelectionEvents();
this._registerDropdownEvents();
this._registerResultsEvents();
this._registerEvents();
// Set the initial state
this.dataAdapter.current(function (initialData) {
self.trigger('selection:update', {
data: initialData
});
});
// Hide the original select
$element[0].classList.add('select2-hidden-accessible');
$element.attr('aria-hidden', 'true');
// Synchronize any monitored attributes
this._syncAttributes();
Utils.StoreData($element[0], 'select2', this);
// Ensure backwards compatibility with $element.data('select2').
$element.data('select2', this);
};
Utils.Extend(Select2, Utils.Observable);
Select2.prototype._generateId = function ($element) {
var id = '';
if ($element.attr('id') != null) {
id = $element.attr('id');
} else if ($element.attr('name') != null) {
id = $element.attr('name') + '-' + Utils.generateChars(2);
} else {
id = Utils.generateChars(4);
}
id = id.replace(/(:|\.|\[|\]|,)/g, '');
id = 'select2-' + id;
return id;
};
Select2.prototype._placeContainer = function ($container) {
$container.insertAfter(this.$element);
var width = this._resolveWidth(this.$element, this.options.get('width'));
if (width != null) {
$container.css('width', width);
}
};
Select2.prototype._resolveWidth = function ($element, method) {
var WIDTH = /^width:(([-+]?([0-9]*\.)?[0-9]+)(px|em|ex|%|in|cm|mm|pt|pc))/i;
if (method == 'resolve') {
var styleWidth = this._resolveWidth($element, 'style');
if (styleWidth != null) {
return styleWidth;
}
return this._resolveWidth($element, 'element');
}
if (method == 'element') {
var elementWidth = $element.outerWidth(false);
if (elementWidth <= 0) {
return 'auto';
}
return elementWidth + 'px';
}
if (method == 'style') {
var style = $element.attr('style');
if (typeof(style) !== 'string') {
return null;
}
var attrs = style.split(';');
for (var i = 0, l = attrs.length; i < l; i = i + 1) {
var attr = attrs[i].replace(/\s/g, '');
var matches = attr.match(WIDTH);
if (matches !== null && matches.length >= 1) {
return matches[1];
}
}
return null;
}
if (method == 'computedstyle') {
var computedStyle = window.getComputedStyle($element[0]);
return computedStyle.width;
}
return method;
};
Select2.prototype._bindAdapters = function () {
this.dataAdapter.bind(this, this.$container);
this.selection.bind(this, this.$container);
this.dropdown.bind(this, this.$container);
this.results.bind(this, this.$container);
};
Select2.prototype._registerDomEvents = function () {
var self = this;
this.$element.on('change.select2', function () {
self.dataAdapter.current(function (data) {
self.trigger('selection:update', {
data: data
});
});
});
this.$element.on('focus.select2', function (evt) {
self.trigger('focus', evt);
});
this._syncA = Utils.bind(this._syncAttributes, this);
this._syncS = Utils.bind(this._syncSubtree, this);
this._observer = new window.MutationObserver(function (mutations) {
self._syncA();
self._syncS(mutations);
});
this._observer.observe(this.$element[0], {
attributes: true,
childList: true,
subtree: false
});
};
Select2.prototype._registerDataEvents = function () {
var self = this;
this.dataAdapter.on('*', function (name, params) {
self.trigger(name, params);
});
};
Select2.prototype._registerSelectionEvents = function () {
var self = this;
var nonRelayEvents = ['toggle', 'focus'];
this.selection.on('toggle', function () {
self.toggleDropdown();
});
this.selection.on('focus', function (params) {
self.focus(params);
});
this.selection.on('*', function (name, params) {
if (nonRelayEvents.indexOf(name) !== -1) {
return;
}
self.trigger(name, params);
});
};
Select2.prototype._registerDropdownEvents = function () {
var self = this;
this.dropdown.on('*', function (name, params) {
self.trigger(name, params);
});
};
Select2.prototype._registerResultsEvents = function () {
var self = this;
this.results.on('*', function (name, params) {
self.trigger(name, params);
});
};
Select2.prototype._registerEvents = function () {
var self = this;
this.on('open', function () {
self.$container[0].classList.add('select2-container--open');
});
this.on('close', function () {
self.$container[0].classList.remove('select2-container--open');
});
this.on('enable', function () {
self.$container[0].classList.remove('select2-container--disabled');
});
this.on('disable', function () {
self.$container[0].classList.add('select2-container--disabled');
});
this.on('blur', function () {
self.$container[0].classList.remove('select2-container--focus');
});
this.on('query', function (params) {
if (!self.isOpen()) {
self.trigger('open', {});
}
this.dataAdapter.query(params, function (data) {
self.trigger('results:all', {
data: data,
query: params
});
});
});
this.on('query:append', function (params) {
this.dataAdapter.query(params, function (data) {
self.trigger('results:append', {
data: data,
query: params
});
});
});
this.on('keypress', function (evt) {
var key = evt.which;
if (self.isOpen()) {
if (key === KEYS.ESC || (key === KEYS.UP && evt.altKey)) {
self.close(evt);
evt.preventDefault();
} else if (key === KEYS.ENTER || key === KEYS.TAB) {
self.trigger('results:select', {});
evt.preventDefault();
} else if ((key === KEYS.SPACE && evt.ctrlKey)) {
self.trigger('results:toggle', {});
evt.preventDefault();
} else if (key === KEYS.UP) {
self.trigger('results:previous', {});
evt.preventDefault();
} else if (key === KEYS.DOWN) {
self.trigger('results:next', {});
evt.preventDefault();
}
} else {
if (key === KEYS.ENTER || key === KEYS.SPACE ||
(key === KEYS.DOWN && evt.altKey)) {
self.open();
evt.preventDefault();
}
}
});
};
Select2.prototype._syncAttributes = function () {
this.options.set('disabled', this.$element.prop('disabled'));
if (this.isDisabled()) {
if (this.isOpen()) {
this.close();
}
this.trigger('disable', {});
} else {
this.trigger('enable', {});
}
};
Select2.prototype._isChangeMutation = function (mutations) {
var self = this;
if (mutations.addedNodes && mutations.addedNodes.length > 0) {
for (var n = 0; n < mutations.addedNodes.length; n++) {
var node = mutations.addedNodes[n];
if (node.selected) {
return true;
}
}
} else if (mutations.removedNodes && mutations.removedNodes.length > 0) {
return true;
} else if (Array.isArray(mutations)) {
return mutations.some(function (mutation) {
return self._isChangeMutation(mutation);
});
}
return false;
};
Select2.prototype._syncSubtree = function (mutations) {
var changed = this._isChangeMutation(mutations);
var self = this;
// Only re-pull the data if we think there is a change
if (changed) {
this.dataAdapter.current(function (currentData) {
self.trigger('selection:update', {
data: currentData
});
});
}
};
/**
* Override the trigger method to automatically trigger pre-events when
* there are events that can be prevented.
*/
Select2.prototype.trigger = function (name, args) {
var actualTrigger = Select2.__super__.trigger;
var preTriggerMap = {
'open': 'opening',
'close': 'closing',
'select': 'selecting',
'unselect': 'unselecting',
'clear': 'clearing'
};
if (args === undefined) {
args = {};
}
if (name in preTriggerMap) {
var preTriggerName = preTriggerMap[name];
var preTriggerArgs = {
prevented: false,
name: name,
args: args
};
actualTrigger.call(this, preTriggerName, preTriggerArgs);
if (preTriggerArgs.prevented) {
args.prevented = true;
return;
}
}
actualTrigger.call(this, name, args);
};
Select2.prototype.toggleDropdown = function () {
if (this.isDisabled()) {
return;
}
if (this.isOpen()) {
this.close();
} else {
this.open();
}
};
Select2.prototype.open = function () {
if (this.isOpen()) {
return;
}
if (this.isDisabled()) {
return;
}
this.trigger('query', {});
};
Select2.prototype.close = function (evt) {
if (!this.isOpen()) {
return;
}
this.trigger('close', { originalEvent : evt });
};
/**
* Helper method to abstract the "enabled" (not "disabled") state of this
* object.
*
* @return {true} if the instance is not disabled.
* @return {false} if the instance is disabled.
*/
Select2.prototype.isEnabled = function () {
return !this.isDisabled();
};
/**
* Helper method to abstract the "disabled" state of this object.
*
* @return {true} if the disabled option is true.
* @return {false} if the disabled option is false.
*/
Select2.prototype.isDisabled = function () {
return this.options.get('disabled');
};
Select2.prototype.isOpen = function () {
return this.$container[0].classList.contains('select2-container--open');
};
Select2.prototype.hasFocus = function () {
return this.$container[0].classList.contains('select2-container--focus');
};
Select2.prototype.focus = function (data) {
// No need to re-trigger focus events if we are already focused
if (this.hasFocus()) {
return;
}
this.$container[0].classList.add('select2-container--focus');
this.trigger('focus', {});
};
Select2.prototype.enable = function (args) {
if (this.options.get('debug') && window.console && console.warn) {
console.warn(
'Select2: The `select2("enable")` method has been deprecated and will' +
' be removed in later Select2 versions. Use $element.prop("disabled")' +
' instead.'
);
}
if (args == null || args.length === 0) {
args = [true];
}
var disabled = !args[0];
this.$element.prop('disabled', disabled);
};
Select2.prototype.data = function () {
if (this.options.get('debug') &&
arguments.length > 0 && window.console && console.warn) {
console.warn(
'Select2: Data can no longer be set using `select2("data")`. You ' +
'should consider setting the value instead using `$element.val()`.'
);
}
var data = [];
this.dataAdapter.current(function (currentData) {
data = currentData;
});
return data;
};
Select2.prototype.val = function (args) {
if (this.options.get('debug') && window.console && console.warn) {
console.warn(
'Select2: The `select2("val")` method has been deprecated and will be' +
' removed in later Select2 versions. Use $element.val() instead.'
);
}
if (args == null || args.length === 0) {
return this.$element.val();
}
var newVal = args[0];
if (Array.isArray(newVal)) {
newVal = newVal.map(function (obj) {
return obj.toString();
});
}
this.$element.val(newVal).trigger('input').trigger('change');
};
Select2.prototype.destroy = function () {
Utils.RemoveData(this.$container[0]);
this.$container.remove();
this._observer.disconnect();
this._observer = null;
this._syncA = null;
this._syncS = null;
this.$element.off('.select2');
this.$element.attr('tabindex',
Utils.GetData(this.$element[0], 'old-tabindex'));
this.$element[0].classList.remove('select2-hidden-accessible');
this.$element.attr('aria-hidden', 'false');
Utils.RemoveData(this.$element[0]);
this.$element.removeData('select2');
this.dataAdapter.destroy();
this.selection.destroy();
this.dropdown.destroy();
this.results.destroy();
this.dataAdapter = null;
this.selection = null;
this.dropdown = null;
this.results = null;
};
Select2.prototype.render = function () {
var $container = $(
'' +
'' +
'' +
''
);
$container.attr('dir', this.options.get('dir'));
this.$container = $container;
this.$container[0].classList
.add('select2-container--' + this.options.get('theme'));
Utils.StoreData($container[0], 'element', this.$element);
return $container;
};
return Select2;
});
S2.define('jquery-mousewheel',[
'jquery'
], function ($) {
// Used to shim jQuery.mousewheel for non-full builds.
return $;
});
S2.define('jquery.select2',[
'jquery',
'jquery-mousewheel',
'./select2/core',
'./select2/defaults',
'./select2/utils'
], function ($, _, Select2, Defaults, Utils) {
if ($.fn.select2 == null) {
// All methods that should return the element
var thisMethods = ['open', 'close', 'destroy'];
$.fn.select2 = function (options) {
options = options || {};
if (typeof options === 'object') {
this.each(function () {
var instanceOptions = $.extend(true, {}, options);
var instance = new Select2($(this), instanceOptions);
});
return this;
} else if (typeof options === 'string') {
var ret;
var args = Array.prototype.slice.call(arguments, 1);
this.each(function () {
var instance = Utils.GetData(this, 'select2');
if (instance == null && window.console && console.error) {
console.error(
'The select2(\'' + options + '\') method was called on an ' +
'element that is not using Select2.'
);
}
ret = instance[options].apply(instance, args);
});
// Check if we should be returning `this`
if (thisMethods.indexOf(options) > -1) {
return this;
}
return ret;
} else {
throw new Error('Invalid arguments for Select2: ' + options);
}
};
}
if ($.fn.select2.defaults == null) {
$.fn.select2.defaults = Defaults;
}
return Select2;
});
// Return the AMD loader configuration so it can be used outside of this file
return {
define: S2.define,
require: S2.require
};
}());
// Autoload the jQuery bindings
// We know that all of the modules exist above this, so we're safe
var select2 = S2.require('jquery.select2');
// Hold the AMD module references on the jQuery function that was just loaded
// This allows Select2 to use the internal loader outside of this file, such
// as in the language files.
jQuery.fn.select2.amd = S2;
// Return the Select2 instance for anyone who is importing it.
return select2;
}));
django-tagulous-1.3.3/tagulous/static/tagulous/lib/select2-4/js/select2.min.js 0000664 0000000 0000000 00000216722 14161666113 0027202 0 ustar 00root root 0000000 0000000 /*! Select2 4.1.0-rc.0 | https://github.com/select2/select2/blob/master/LICENSE.md */
!function(n){"function"==typeof define&&define.amd?define(["jquery"],n):"object"==typeof module&&module.exports?module.exports=function(e,t){return void 0===t&&(t="undefined"!=typeof window?require("jquery"):require("jquery")(e)),n(t),t}:n(jQuery)}(function(t){var e,n,s,p,r,o,h,f,g,m,y,v,i,a,_,s=(t&&t.fn&&t.fn.select2&&t.fn.select2.amd&&(u=t.fn.select2.amd),u&&u.requirejs||(u?n=u:u={},g={},m={},y={},v={},i=Object.prototype.hasOwnProperty,a=[].slice,_=/\.js$/,h=function(e,t){var n,s,i=c(e),r=i[0],t=t[1];return e=i[1],r&&(n=x(r=l(r,t))),r?e=n&&n.normalize?n.normalize(e,(s=t,function(e){return l(e,s)})):l(e,t):(r=(i=c(e=l(e,t)))[0],e=i[1],r&&(n=x(r))),{f:r?r+"!"+e:e,n:e,pr:r,p:n}},f={require:function(e){return w(e)},exports:function(e){var t=g[e];return void 0!==t?t:g[e]={}},module:function(e){return{id:e,uri:"",exports:g[e],config:(t=e,function(){return y&&y.config&&y.config[t]||{}})};var t}},r=function(e,t,n,s){var i,r,o,a,l,c=[],u=typeof n,d=A(s=s||e);if("undefined"==u||"function"==u){for(t=!t.length&&n.length?["require","exports","module"]:t,a=0;a":">",'"':""","'":"'","/":"/"};return"string"!=typeof e?e:String(e).replace(/[&<>"'\/\\]/g,function(e){return t[e]})},s.__cache={};var n=0;return s.GetUniqueElementId=function(e){var t=e.getAttribute("data-select2-id");return null!=t||(t=e.id?"select2-data-"+e.id:"select2-data-"+(++n).toString()+"-"+s.generateChars(4),e.setAttribute("data-select2-id",t)),t},s.StoreData=function(e,t,n){e=s.GetUniqueElementId(e);s.__cache[e]||(s.__cache[e]={}),s.__cache[e][t]=n},s.GetData=function(e,t){var n=s.GetUniqueElementId(e);return t?s.__cache[n]&&null!=s.__cache[n][t]?s.__cache[n][t]:r(e).data(t):s.__cache[n]},s.RemoveData=function(e){var t=s.GetUniqueElementId(e);null!=s.__cache[t]&&delete s.__cache[t],e.removeAttribute("data-select2-id")},s.copyNonInternalCssClasses=function(e,t){var n=(n=e.getAttribute("class").trim().split(/\s+/)).filter(function(e){return 0===e.indexOf("select2-")}),t=(t=t.getAttribute("class").trim().split(/\s+/)).filter(function(e){return 0!==e.indexOf("select2-")}),t=n.concat(t);e.setAttribute("class",t.join(" "))},s}),u.define("select2/results",["jquery","./utils"],function(d,p){function s(e,t,n){this.$element=e,this.data=n,this.options=t,s.__super__.constructor.call(this)}return p.Extend(s,p.Observable),s.prototype.render=function(){var e=d('
');return this.options.get("multiple")&&e.attr("aria-multiselectable","true"),this.$results=e},s.prototype.clear=function(){this.$results.empty()},s.prototype.displayMessage=function(e){var t=this.options.get("escapeMarkup");this.clear(),this.hideLoading();var n=d(''),s=this.options.get("translations").get(e.message);n.append(t(s(e.args))),n[0].className+=" select2-results__message",this.$results.append(n)},s.prototype.hideMessages=function(){this.$results.find(".select2-results__message").remove()},s.prototype.append=function(e){this.hideLoading();var t=[];if(null!=e.results&&0!==e.results.length){e.results=this.sort(e.results);for(var n=0;n",{class:"select2-results__options select2-results__options--nested",role:"none"});i.append(l),o.append(a),o.append(i)}else this.template(e,t);return p.StoreData(t,"data",e),t},s.prototype.bind=function(t,e){var i=this,n=t.id+"-results";this.$results.attr("id",n),t.on("results:all",function(e){i.clear(),i.append(e.data),t.isOpen()&&(i.setClasses(),i.highlightFirstItem())}),t.on("results:append",function(e){i.append(e.data),t.isOpen()&&i.setClasses()}),t.on("query",function(e){i.hideMessages(),i.showLoading(e)}),t.on("select",function(){t.isOpen()&&(i.setClasses(),i.options.get("scrollAfterSelect")&&i.highlightFirstItem())}),t.on("unselect",function(){t.isOpen()&&(i.setClasses(),i.options.get("scrollAfterSelect")&&i.highlightFirstItem())}),t.on("open",function(){i.$results.attr("aria-expanded","true"),i.$results.attr("aria-hidden","false"),i.setClasses(),i.ensureHighlightVisible()}),t.on("close",function(){i.$results.attr("aria-expanded","false"),i.$results.attr("aria-hidden","true"),i.$results.removeAttr("aria-activedescendant")}),t.on("results:toggle",function(){var e=i.getHighlightedResults();0!==e.length&&e.trigger("mouseup")}),t.on("results:select",function(){var e,t=i.getHighlightedResults();0!==t.length&&(e=p.GetData(t[0],"data"),t.hasClass("select2-results__option--selected")?i.trigger("close",{}):i.trigger("select",{data:e}))}),t.on("results:previous",function(){var e,t=i.getHighlightedResults(),n=i.$results.find(".select2-results__option--selectable"),s=n.index(t);s<=0||(e=s-1,0===t.length&&(e=0),(s=n.eq(e)).trigger("mouseenter"),t=i.$results.offset().top,n=s.offset().top,s=i.$results.scrollTop()+(n-t),0===e?i.$results.scrollTop(0):n-t<0&&i.$results.scrollTop(s))}),t.on("results:next",function(){var e,t=i.getHighlightedResults(),n=i.$results.find(".select2-results__option--selectable"),s=n.index(t)+1;s>=n.length||((e=n.eq(s)).trigger("mouseenter"),t=i.$results.offset().top+i.$results.outerHeight(!1),n=e.offset().top+e.outerHeight(!1),e=i.$results.scrollTop()+n-t,0===s?i.$results.scrollTop(0):tthis.$results.outerHeight()||s<0)&&this.$results.scrollTop(n))},s.prototype.template=function(e,t){var n=this.options.get("templateResult"),s=this.options.get("escapeMarkup"),e=n(e,t);null==e?t.style.display="none":"string"==typeof e?t.innerHTML=s(e):d(t).append(e)},s}),u.define("select2/keys",[],function(){return{BACKSPACE:8,TAB:9,ENTER:13,SHIFT:16,CTRL:17,ALT:18,ESC:27,SPACE:32,PAGE_UP:33,PAGE_DOWN:34,END:35,HOME:36,LEFT:37,UP:38,RIGHT:39,DOWN:40,DELETE:46}}),u.define("select2/selection/base",["jquery","../utils","../keys"],function(n,s,i){function r(e,t){this.$element=e,this.options=t,r.__super__.constructor.call(this)}return s.Extend(r,s.Observable),r.prototype.render=function(){var e=n('');return this._tabindex=0,null!=s.GetData(this.$element[0],"old-tabindex")?this._tabindex=s.GetData(this.$element[0],"old-tabindex"):null!=this.$element.attr("tabindex")&&(this._tabindex=this.$element.attr("tabindex")),e.attr("title",this.$element.attr("title")),e.attr("tabindex",this._tabindex),e.attr("aria-disabled","false"),this.$selection=e},r.prototype.bind=function(e,t){var n=this,s=e.id+"-results";this.container=e,this.$selection.on("focus",function(e){n.trigger("focus",e)}),this.$selection.on("blur",function(e){n._handleBlur(e)}),this.$selection.on("keydown",function(e){n.trigger("keypress",e),e.which===i.SPACE&&e.preventDefault()}),e.on("results:focus",function(e){n.$selection.attr("aria-activedescendant",e.data._resultId)}),e.on("selection:update",function(e){n.update(e.data)}),e.on("open",function(){n.$selection.attr("aria-expanded","true"),n.$selection.attr("aria-owns",s),n._attachCloseHandler(e)}),e.on("close",function(){n.$selection.attr("aria-expanded","false"),n.$selection.removeAttr("aria-activedescendant"),n.$selection.removeAttr("aria-owns"),n.$selection.trigger("focus"),n._detachCloseHandler(e)}),e.on("enable",function(){n.$selection.attr("tabindex",n._tabindex),n.$selection.attr("aria-disabled","false")}),e.on("disable",function(){n.$selection.attr("tabindex","-1"),n.$selection.attr("aria-disabled","true")})},r.prototype._handleBlur=function(e){var t=this;window.setTimeout(function(){document.activeElement==t.$selection[0]||n.contains(t.$selection[0],document.activeElement)||t.trigger("blur",e)},1)},r.prototype._attachCloseHandler=function(e){n(document.body).on("mousedown.select2."+e.id,function(e){var t=n(e.target).closest(".select2");n(".select2.select2-container--open").each(function(){this!=t[0]&&s.GetData(this,"element").select2("close")})})},r.prototype._detachCloseHandler=function(e){n(document.body).off("mousedown.select2."+e.id)},r.prototype.position=function(e,t){t.find(".selection").append(e)},r.prototype.destroy=function(){this._detachCloseHandler(this.container)},r.prototype.update=function(e){throw new Error("The `update` method must be defined in child classes.")},r.prototype.isEnabled=function(){return!this.isDisabled()},r.prototype.isDisabled=function(){return this.options.get("disabled")},r}),u.define("select2/selection/single",["jquery","./base","../utils","../keys"],function(e,t,n,s){function i(){i.__super__.constructor.apply(this,arguments)}return n.Extend(i,t),i.prototype.render=function(){var e=i.__super__.render.call(this);return e[0].classList.add("select2-selection--single"),e.html(''),e},i.prototype.bind=function(t,e){var n=this;i.__super__.bind.apply(this,arguments);var s=t.id+"-container";this.$selection.find(".select2-selection__rendered").attr("id",s).attr("role","textbox").attr("aria-readonly","true"),this.$selection.attr("aria-labelledby",s),this.$selection.attr("aria-controls",s),this.$selection.on("mousedown",function(e){1===e.which&&n.trigger("toggle",{originalEvent:e})}),this.$selection.on("focus",function(e){}),this.$selection.on("blur",function(e){}),t.on("focus",function(e){t.isOpen()||n.$selection.trigger("focus")})},i.prototype.clear=function(){var e=this.$selection.find(".select2-selection__rendered");e.empty(),e.removeAttr("title")},i.prototype.display=function(e,t){var n=this.options.get("templateSelection");return this.options.get("escapeMarkup")(n(e,t))},i.prototype.selectionContainer=function(){return e("")},i.prototype.update=function(e){var t,n;0!==e.length?(n=e[0],t=this.$selection.find(".select2-selection__rendered"),e=this.display(n,t),t.empty().append(e),(n=n.title||n.text)?t.attr("title",n):t.removeAttr("title")):this.clear()},i}),u.define("select2/selection/multiple",["jquery","./base","../utils"],function(i,e,c){function r(e,t){r.__super__.constructor.apply(this,arguments)}return c.Extend(r,e),r.prototype.render=function(){var e=r.__super__.render.call(this);return e[0].classList.add("select2-selection--multiple"),e.html('