djblets_0.7~git20120402.orig/0000755000175000017500000000000011746533534014224 5ustar diondiondjblets_0.7~git20120402.orig/tests/0000755000175000017500000000000011746533534015366 5ustar diondiondjblets_0.7~git20120402.orig/tests/settings.py0000644000175000017500000000555311746533534017610 0ustar diondionimport os DEBUG = True TEMPLATE_DEBUG = DEBUG ADMINS = ( # ('Your Name', 'your_email@domain.com'), ) MANAGERS = ADMINS DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': 'djblets_test.db', } } # Local time zone for this installation. Choices can be found here: # http://en.wikipedia.org/wiki/List_of_tz_zones_by_name # although not all choices may be available on all operating systems. # If running in a Windows environment this must be set to the same as your # system time zone. TIME_ZONE = 'America/Chicago' # Language code for this installation. All choices can be found here: # http://www.i18nguy.com/unicode/language-identifiers.html LANGUAGE_CODE = 'en-us' SITE_ID = 1 # If you set this to False, Django will make some optimizations so as not # to load the internationalization machinery. USE_I18N = True # Absolute path to the directory that holds media. # Example: "/home/media/media.lawrence.com/" STATIC_ROOT = 'tests/media' EXTENSIONS_STATIC_ROOT = 'tests/ext' # URL that handles the media served from STATIC_ROOT. Make sure to use a # trailing slash if there is a path component (optional in other cases). # Examples: "http://media.lawrence.com", "http://example.com/media/" STATIC_URL = '/' # URL prefix for admin media -- CSS, JavaScript and images. Make sure to use a # trailing slash. # Examples: "http://foo.com/media/", "/media/". ADMIN_MEDIA_PREFIX = '/media/' # Make this unique, and don't share it with anybody. SECRET_KEY = 'af=y9ydd51a0g#bevy0+p#(7ime@m#k)$4$9imoz*!rl97w0j0' # List of callables that know how to import templates from various sources. TEMPLATE_LOADERS = ( 'django.template.loaders.filesystem.Loader', 'django.template.loaders.app_directories.Loader', # 'django.template.loaders.eggs.load_template_source', ) MIDDLEWARE_CLASSES = ( 'django.middleware.common.CommonMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.middleware.doc.XViewMiddleware', ) ROOT_URLCONF = 'djblets.testing.urls' TEMPLATE_DIRS = ( # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates". # Always use forward slashes, even on Windows. # Don't forget to use absolute paths, not relative paths. ) INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.sites', 'django.contrib.staticfiles', ] base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "djblets")) for entry in os.listdir(base_path): fullpath = os.path.join(base_path, entry) if (os.path.isdir(fullpath) and os.path.exists(os.path.join(fullpath, "__init__.py"))): INSTALLED_APPS += ["djblets.%s" % entry] print INSTALLED_APPS djblets_0.7~git20120402.orig/tests/runtests.py0000755000175000017500000000272411746533534017637 0ustar diondion#!/usr/bin/env python import nose import os import sys def run_tests(verbosity=1, interactive=False): from django.conf import settings from django.core import management from django.db import connection from django.test.utils import setup_test_environment, \ teardown_test_environment setup_test_environment() settings.DEBUG = False if not os.path.exists(settings.EXTENSIONS_STATIC_ROOT): os.mkdir(settings.EXTENSIONS_STATIC_ROOT, 0755) old_db_name = 'default' connection.creation.create_test_db(verbosity, autoclobber=not interactive) management.call_command('syncdb', verbosity=verbosity, interactive=interactive) nose_argv = ['runtests.py', '-v', '--with-coverage', '--with-doctest', '--doctest-extension=.txt', '--cover-package=djblets'] # Don't test context manager code on Python 2.4. try: import contextlib except ImportError: nose_argv.append('--ignore-files=contextmanagers.py') if len(sys.argv) > 2: node_argv += sys.argv[2:] nose.main(argv=nose_argv) connection.creation.destroy_test_db(old_name, verbosity) teardown_test_environment() if __name__ == "__main__": os.chdir(os.path.join(os.path.dirname(__file__), "..")) sys.path.insert(0, os.getcwd()) os.environ['DJANGO_SETTINGS_MODULE'] = "tests.settings" run_tests() djblets_0.7~git20120402.orig/tests/run-pyflakes.py0000755000175000017500000000210011746533534020354 0ustar diondion#!/usr/bin/env python # # Utility script to run pyflakes with the modules we care about and # exclude errors we know to be fine. import os import re import subprocess import sys def main(): cur_dir = os.path.dirname(__file__) os.chdir(os.path.join(cur_dir, "..")) modules = sys.argv[1:] if not modules: modules = ['djblets'] p = subprocess.Popen(['pyflakes'] + modules, stderr=subprocess.PIPE, stdout=subprocess.PIPE, close_fds=True) contents = p.stdout.readlines() # Read in the exclusions file exclusions = {} fp = open(os.path.join(cur_dir, "pyflakes.exclude"), "r") for line in fp.readlines(): exclusions[line.rstrip()] = 1 fp.close() # Now filter things for line in contents: line = line.rstrip() test_line = re.sub(r':[0-9]+:', r':*:', line, 1) test_line = re.sub(r'line [0-9]+', r'line *', test_line) if test_line not in exclusions: print line if __name__ == "__main__": main() djblets_0.7~git20120402.orig/tests/pyflakes.exclude0000644000175000017500000000367411746533534020571 0ustar diondiondjblets/extensions/base.py:*: redefinition of unused 'pkg_resources' from line * djblets/extensions/base.py:*: 'pkg_resources' imported but unused djblets/feedview/feedparser.py:*: redefinition of unused '_StringIO' from line * djblets/feedview/feedparser.py:*: redefinition of unused 'gzip' from line * djblets/feedview/feedparser.py:*: redefinition of unused 'zlib' from line * djblets/feedview/feedparser.py:*: redefinition of unused '_xmlescape' from line * djblets/feedview/feedparser.py:*: redefinition of unused 'binascii' from line * djblets/feedview/feedparser.py:*: redefinition of unused 'base64' from line * djblets/feedview/feedparser.py:*: 'cjkcodecs' imported but unused djblets/feedview/feedparser.py:*: 'iconv_codec' imported but unused djblets/feedview/feedparser.py:*: redefinition of unused 'chardet' from line * djblets/feedview/feedparser.py:*: redefinition of unused 'name2codepoint' from line * djblets/feedview/feedparser.py:*: redefinition of unused 'codepoint2name' from line * djblets/feedview/feedparser.py:*: redefinition of unused 'BeautifulSoup' from line * djblets/feedview/feedparser.py:*: redefinition of unused 'OptionParser' from line * djblets/feedview/feedparser.py:*: redefinition of function '_tidy' from line * djblets/feedview/test_urls.py:*: 'handler500' imported but unused djblets/log/__init__.py:*: redefinition of unused 'WatchedFileHandler' from line * djblets/util/rooturl.py:*: 'handler404' imported but unused djblets/util/rooturl.py:*: 'handler500' imported but unused djblets/util/misc.py:*: redefinition of unused 'pickle' from line * djblets/util/misc.py:*: redefinition of unused 'StringIO' from line * djblets/util/templatetags/djblets_images.py:*: redefinition of unused 'StringIO' from line * djblets/util/templatetags/djblets_images.py:*: redefinition of unused 'Image' from line * djblets/webapi/core.py:*: 'BasicAPIEncoder' imported but unused djblets/webapi/resources.py:*: redefinition of unused 'sha1' from line * djblets_0.7~git20120402.orig/tests/__init__.py0000644000175000017500000000000011746533534017465 0ustar diondiondjblets_0.7~git20120402.orig/setup.py0000755000175000017500000000546711746533534015755 0ustar diondion#!/usr/bin/env python # # setup.py -- Installation for djblets # # Copyright (C) 2008 Christian Hammond # Copyright (C) 2007-2008 David Trowbridge # # 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. from ez_setup import use_setuptools use_setuptools() from setuptools import setup, find_packages from setuptools.command.test import test def run_tests(*args): import os os.system("tests/runtests.py") test.run_tests = run_tests from djblets import get_package_version, is_release, VERSION PACKAGE_NAME = 'Djblets' if is_release(): download_url = 'http://downloads.reviewboard.org/releases/%s/%s.%s/' % \ (PACKAGE_NAME, VERSION[0], VERSION[1]) else: download_url = 'http://downloads.reviewboard.org/nightlies/' setup(name=PACKAGE_NAME, version=get_package_version(), test_suite="dummy", license="MIT", description="A collection of useful classes and functions for Django", packages=find_packages(), install_requires=[ 'Django>=1.4', 'PIL', 'pytz' ], dependency_links = [ "http://downloads.reviewboard.org/mirror/", download_url, ], include_package_data=True, zip_safe=False, maintainer="Christian Hammond", maintainer_email="chipx86@chipx86.com", url="http://www.reviewboard.org/wiki/Djblets", download_url=download_url, classifiers=[ "Development Status :: 4 - Beta", "Environment :: Web Environment", "Framework :: Django", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", "Programming Language :: Python", "Topic :: Software Development", "Topic :: Software Development :: Libraries :: Python Modules", ] ) djblets_0.7~git20120402.orig/setup.cfg0000644000175000017500000000045211746533534016046 0ustar diondion[egg_info] tag_build = .dev tag_svn_revision = 1 [aliases] snapshot = egg_info -Dr nightly = egg_info -dR alpha2 = egg_info -DRb alpha2 alpha1 = egg_info -DRb alpha1 beta2 = egg_info -DRb beta2 beta1 = egg_info -DRb beta1 rc1 = egg_info -DRb rc1 rc2 = egg_info -DRb rc2 release = egg_info -DRb '' djblets_0.7~git20120402.orig/ez_setup.py0000644000175000017500000002231311746533534016435 0ustar diondion#!python """Bootstrap setuptools installation If you want to use setuptools in your package's setup.py, just include this file in the same directory with it, and add this to the top of your setup.py:: from ez_setup import use_setuptools use_setuptools() If you want to require a specific version of setuptools, set a download mirror, or use an alternate download directory, you can do so by supplying the appropriate options to ``use_setuptools()``. This file can also be run as a script to install or upgrade setuptools. """ import sys DEFAULT_VERSION = "0.6c8" DEFAULT_URL = "http://pypi.python.org/packages/%s/s/setuptools/" % sys.version[:3] md5_data = { 'setuptools-0.6b1-py2.3.egg': '8822caf901250d848b996b7f25c6e6ca', 'setuptools-0.6b1-py2.4.egg': 'b79a8a403e4502fbb85ee3f1941735cb', 'setuptools-0.6b2-py2.3.egg': '5657759d8a6d8fc44070a9d07272d99b', 'setuptools-0.6b2-py2.4.egg': '4996a8d169d2be661fa32a6e52e4f82a', 'setuptools-0.6b3-py2.3.egg': 'bb31c0fc7399a63579975cad9f5a0618', 'setuptools-0.6b3-py2.4.egg': '38a8c6b3d6ecd22247f179f7da669fac', 'setuptools-0.6b4-py2.3.egg': '62045a24ed4e1ebc77fe039aa4e6f7e5', 'setuptools-0.6b4-py2.4.egg': '4cb2a185d228dacffb2d17f103b3b1c4', 'setuptools-0.6c1-py2.3.egg': 'b3f2b5539d65cb7f74ad79127f1a908c', 'setuptools-0.6c1-py2.4.egg': 'b45adeda0667d2d2ffe14009364f2a4b', 'setuptools-0.6c2-py2.3.egg': 'f0064bf6aa2b7d0f3ba0b43f20817c27', 'setuptools-0.6c2-py2.4.egg': '616192eec35f47e8ea16cd6a122b7277', 'setuptools-0.6c3-py2.3.egg': 'f181fa125dfe85a259c9cd6f1d7b78fa', 'setuptools-0.6c3-py2.4.egg': 'e0ed74682c998bfb73bf803a50e7b71e', 'setuptools-0.6c3-py2.5.egg': 'abef16fdd61955514841c7c6bd98965e', 'setuptools-0.6c4-py2.3.egg': 'b0b9131acab32022bfac7f44c5d7971f', 'setuptools-0.6c4-py2.4.egg': '2a1f9656d4fbf3c97bf946c0a124e6e2', 'setuptools-0.6c4-py2.5.egg': '8f5a052e32cdb9c72bcf4b5526f28afc', 'setuptools-0.6c5-py2.3.egg': 'ee9fd80965da04f2f3e6b3576e9d8167', 'setuptools-0.6c5-py2.4.egg': 'afe2adf1c01701ee841761f5bcd8aa64', 'setuptools-0.6c5-py2.5.egg': 'a8d3f61494ccaa8714dfed37bccd3d5d', 'setuptools-0.6c6-py2.3.egg': '35686b78116a668847237b69d549ec20', 'setuptools-0.6c6-py2.4.egg': '3c56af57be3225019260a644430065ab', 'setuptools-0.6c6-py2.5.egg': 'b2f8a7520709a5b34f80946de5f02f53', 'setuptools-0.6c7-py2.3.egg': '209fdf9adc3a615e5115b725658e13e2', 'setuptools-0.6c7-py2.4.egg': '5a8f954807d46a0fb67cf1f26c55a82e', 'setuptools-0.6c7-py2.5.egg': '45d2ad28f9750e7434111fde831e8372', 'setuptools-0.6c8-py2.3.egg': '50759d29b349db8cfd807ba8303f1902', 'setuptools-0.6c8-py2.4.egg': 'cba38d74f7d483c06e9daa6070cce6de', 'setuptools-0.6c8-py2.5.egg': '1721747ee329dc150590a58b3e1ac95b', } import sys, os def _validate_md5(egg_name, data): if egg_name in md5_data: from md5 import md5 digest = md5(data).hexdigest() if digest != md5_data[egg_name]: print >>sys.stderr, ( "md5 validation of %s failed! (Possible download problem?)" % egg_name ) sys.exit(2) return data def use_setuptools( version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir, download_delay=15 ): """Automatically find/download setuptools and make it available on sys.path `version` should be a valid setuptools version number that is available as an egg for download under the `download_base` URL (which should end with a '/'). `to_dir` is the directory where setuptools will be downloaded, if it is not already available. If `download_delay` is specified, it should be the number of seconds that will be paused before initiating a download, should one be required. If an older version of setuptools is installed, this routine will print a message to ``sys.stderr`` and raise SystemExit in an attempt to abort the calling script. """ was_imported = 'pkg_resources' in sys.modules or 'setuptools' in sys.modules def do_download(): egg = download_setuptools(version, download_base, to_dir, download_delay) sys.path.insert(0, egg) import setuptools; setuptools.bootstrap_install_from = egg try: import pkg_resources except ImportError: return do_download() try: pkg_resources.require("setuptools>="+version); return except pkg_resources.VersionConflict, e: if was_imported: print >>sys.stderr, ( "The required version of setuptools (>=%s) is not available, and\n" "can't be installed while this script is running. Please install\n" " a more recent version first, using 'easy_install -U setuptools'." "\n\n(Currently using %r)" ) % (version, e.args[0]) sys.exit(2) else: del pkg_resources, sys.modules['pkg_resources'] # reload ok return do_download() except pkg_resources.DistributionNotFound: return do_download() def download_setuptools( version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir, delay = 15 ): """Download setuptools from a specified location and return its filename `version` should be a valid setuptools version number that is available as an egg for download under the `download_base` URL (which should end with a '/'). `to_dir` is the directory where the egg will be downloaded. `delay` is the number of seconds to pause before an actual download attempt. """ import urllib2, shutil egg_name = "setuptools-%s-py%s.egg" % (version,sys.version[:3]) url = download_base + egg_name saveto = os.path.join(to_dir, egg_name) src = dst = None if not os.path.exists(saveto): # Avoid repeated downloads try: from distutils import log if delay: log.warn(""" --------------------------------------------------------------------------- This script requires setuptools version %s to run (even to display help). I will attempt to download it for you (from %s), but you may need to enable firewall access for this script first. I will start the download in %d seconds. (Note: if this machine does not have network access, please obtain the file %s and place it in this directory before rerunning this script.) ---------------------------------------------------------------------------""", version, download_base, delay, url ); from time import sleep; sleep(delay) log.warn("Downloading %s", url) src = urllib2.urlopen(url) # Read/write all in one block, so we don't create a corrupt file # if the download is interrupted. data = _validate_md5(egg_name, src.read()) dst = open(saveto,"wb"); dst.write(data) finally: if src: src.close() if dst: dst.close() return os.path.realpath(saveto) def main(argv, version=DEFAULT_VERSION): """Install or upgrade setuptools and EasyInstall""" try: import setuptools except ImportError: egg = None try: egg = download_setuptools(version, delay=0) sys.path.insert(0,egg) from setuptools.command.easy_install import main return main(list(argv)+[egg]) # we're done here finally: if egg and os.path.exists(egg): os.unlink(egg) else: if setuptools.__version__ == '0.0.1': print >>sys.stderr, ( "You have an obsolete version of setuptools installed. Please\n" "remove it from your system entirely before rerunning this script." ) sys.exit(2) req = "setuptools>="+version import pkg_resources try: pkg_resources.require(req) except pkg_resources.VersionConflict: try: from setuptools.command.easy_install import main except ImportError: from easy_install import main main(list(argv)+[download_setuptools(delay=0)]) sys.exit(0) # try to force an exit else: if argv: from setuptools.command.easy_install import main main(argv) else: print "Setuptools version",version,"or greater has been installed." print '(Run "ez_setup.py -U setuptools" to reinstall or upgrade.)' def update_md5(filenames): """Update our built-in md5 registry""" import re from md5 import md5 for name in filenames: base = os.path.basename(name) f = open(name,'rb') md5_data[base] = md5(f.read()).hexdigest() f.close() data = [" %r: %r,\n" % it for it in md5_data.items()] data.sort() repl = "".join(data) import inspect srcfile = inspect.getsourcefile(sys.modules[__name__]) f = open(srcfile, 'rb'); src = f.read(); f.close() match = re.search("\nmd5_data = {\n([^}]+)}", src) if not match: print >>sys.stderr, "Internal error!" sys.exit(2) src = src[:match.start(1)] + repl + src[match.end(1):] f = open(srcfile,'w') f.write(src) f.close() if __name__=='__main__': if len(sys.argv)>2 and sys.argv[1]=='--md5update': update_md5(sys.argv[2:]) else: main(sys.argv[1:]) djblets_0.7~git20120402.orig/djblets/0000755000175000017500000000000011746533534015653 5ustar diondiondjblets_0.7~git20120402.orig/djblets/webapi/0000755000175000017500000000000011746533534017122 5ustar diondiondjblets_0.7~git20120402.orig/djblets/webapi/tests.py0000644000175000017500000001662211746533534020645 0ustar diondion# # tests.py -- Unit tests for classes in djblets.webapi # # Copyright (c) 2011 Beanbag, Inc. # # 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. from django.test.client import RequestFactory from djblets.util.testing import TestCase from djblets.webapi.resources import WebAPIResource, unregister_resource class WebAPIResourceTests(TestCase): def setUp(self): self.factory = RequestFactory() self.test_resource = None def tearDown(self): if self.test_resource: unregister_resource(self.test_resource) def test_vendor_mimetypes(self): """Testing WebAPIResource with vendor-specific mimetypes""" class TestResource(WebAPIResource): mimetype_vendor = 'djblets' self.test_resource = TestResource() self.assertEqual(len(self.test_resource.allowed_list_mimetypes), 4) self.assertEqual(len(self.test_resource.allowed_item_mimetypes), 4) self.assertTrue('application/json' in self.test_resource.allowed_list_mimetypes) self.assertTrue('application/xml' in self.test_resource.allowed_list_mimetypes) self.assertTrue('application/vnd.djblets.testresources+json' in self.test_resource.allowed_list_mimetypes) self.assertTrue('application/vnd.djblets.testresources+xml' in self.test_resource.allowed_list_mimetypes) self.assertTrue('application/json' in self.test_resource.allowed_item_mimetypes) self.assertTrue('application/xml' in self.test_resource.allowed_item_mimetypes) self.assertTrue('application/vnd.djblets.testresource+json' in self.test_resource.allowed_item_mimetypes) self.assertTrue('application/vnd.djblets.testresource+xml' in self.test_resource.allowed_item_mimetypes) def test_vendor_mimetypes_with_custom(self): """Testing WebAPIResource with vendor-specific and custom mimetypes""" class TestResource(WebAPIResource): mimetype_vendor = 'djblets' allowed_item_mimetypes = WebAPIResource.allowed_item_mimetypes + [ 'text/html', ] self.test_resource = TestResource() self.assertEqual(len(self.test_resource.allowed_list_mimetypes), 4) self.assertEqual(len(self.test_resource.allowed_item_mimetypes), 5) self.assertTrue('application/json' in self.test_resource.allowed_list_mimetypes) self.assertTrue('application/xml' in self.test_resource.allowed_list_mimetypes) self.assertTrue('application/vnd.djblets.testresources+json' in self.test_resource.allowed_list_mimetypes) self.assertTrue('application/vnd.djblets.testresources+xml' in self.test_resource.allowed_list_mimetypes) self.assertTrue('application/json' in self.test_resource.allowed_item_mimetypes) self.assertTrue('application/xml' in self.test_resource.allowed_item_mimetypes) self.assertTrue('application/vnd.djblets.testresource+json' in self.test_resource.allowed_item_mimetypes) self.assertTrue('application/vnd.djblets.testresource+xml' in self.test_resource.allowed_item_mimetypes) self.assertTrue('application/vnd.djblets.testresource+xml' in self.test_resource.allowed_item_mimetypes) self.assertTrue('text/html' in self.test_resource.allowed_item_mimetypes) def test_get_with_vendor_mimetype(self): """Testing WebAPIResource with GET and vendor-specific mimetypes""" class TestResource(WebAPIResource): allowed_methods = ('GET', 'POST', 'PUT', 'DELETE') mimetype_vendor = 'djblets' uri_object_key = 'id' def get(self, *args, **kwargs): return 200, {} create = get update = get delete = get self.test_resource = TestResource() self._test_mimetype_responses( self.test_resource, '/api/tests/', 'application/vnd.djblets.testresources+json', 'application/vnd.djblets.testresources+xml') self._test_mimetype_responses( self.test_resource, '/api/tests/', 'application/vnd.djblets.testresource+json', 'application/vnd.djblets.testresource+xml', method='post') self._test_mimetype_responses( self.test_resource, '/api/tests/1/', 'application/vnd.djblets.testresource+json', 'application/vnd.djblets.testresource+xml', view_kwargs={'id': 1}, method='put') self._test_mimetype_responses( self.test_resource, '/api/tests/1/', 'application/vnd.djblets.testresource+json', 'application/vnd.djblets.testresource+xml', view_kwargs={'id': 1}, method='delete') def _test_mimetype_responses(self, resource, url, json_mimetype, xml_mimetype, **kwargs): self._test_mimetype_response(resource, url, '*/*', json_mimetype, **kwargs) self._test_mimetype_response(resource, url, 'application/json', json_mimetype, **kwargs) self._test_mimetype_response(resource, url, json_mimetype, json_mimetype, **kwargs) self._test_mimetype_response(resource, url, 'application/xml', xml_mimetype, **kwargs) self._test_mimetype_response(resource, url, xml_mimetype, xml_mimetype, **kwargs) def _test_mimetype_response(self, resource, url, accept_mimetype, response_mimetype, method='get', view_kwargs={}): func = getattr(self.factory, method) if accept_mimetype: request = func(url, HTTP_ACCEPT=accept_mimetype) else: request = func(url) response = resource(request, **view_kwargs) print response self.assertEqual(response.status_code, 200) self.assertEqual(response['Content-Type'], response_mimetype) djblets_0.7~git20120402.orig/djblets/webapi/resources.py0000644000175000017500000013245211746533534021515 0ustar diondiontry: from hashlib import sha1 except ImportError: from sha import sha as sha1 from django.conf.urls.defaults import include, patterns, url from django.contrib.auth.models import User, Group from django.core.urlresolvers import reverse from django.db import models from django.db.models.query import QuerySet from django.http import HttpResponseNotAllowed, HttpResponse, \ HttpResponseNotModified from django.views.decorators.vary import vary_on_headers from djblets.util.decorators import augment_method_from from djblets.util.http import get_modified_since, etag_if_none_match, \ set_last_modified, set_etag, \ get_http_requested_mimetype from djblets.util.misc import never_cache_patterns from djblets.webapi.auth import check_login from djblets.webapi.core import WebAPIResponse, \ WebAPIResponseError, \ WebAPIResponsePaginated, \ SPECIAL_PARAMS from djblets.webapi.decorators import webapi_login_required, \ webapi_request_fields, \ webapi_response_errors from djblets.webapi.errors import DOES_NOT_EXIST, \ NOT_LOGGED_IN, \ PERMISSION_DENIED, \ WebAPIError _model_to_resources = {} _name_to_resources = {} _class_to_resources = {} class WebAPIResource(object): """A resource living at a specific URL, representing an object or list of objects. A WebAPIResource is a RESTful resource living at a specific URL. It can represent either an object or a list of objects, and can respond to various HTTP methods (GET, POST, PUT, DELETE). Subclasses are expected to override functions and variables in order to provide specific functionality, such as modifying the resource or creating a new resource. Representing Models ------------------- Most resources will have ``model`` set to a Model subclass, and ``fields`` set to list the fields that would be shown when Each resource will also include a ``link`` dictionary that maps a key (resource name or action) to a dictionary containing the URL (``href``) and the HTTP method that's to be used for that URL (``method``). This will include a special ``self`` key that links to that resource's actual location. An example of this might be:: 'links': { 'self': { 'method': 'GET', 'href': '/path/to/this/resource/' }, 'update': { 'method': 'PUT', 'href': '/path/to/this/resource/' } } Resources associated with a model may want to override the ``get_queryset`` function to return a queryset with a more specific query. By default, an individual object's key name in the resulting payloads will be set to the lowercase class name of the object, and the plural version used for lists will be the same but with 's' appended to it. This can be overridden by setting ``name`` and ``name_plural``. Matching Objects ---------------- Objects are generally queried by their numeric object ID and mapping that to the object's ``pk`` attribute. For this to work, the ``uri_object_key`` attribute must be set to the name in the regex for the URL that will be captured and passed to the handlers for this resource. The ``uri_object_key_regex`` attribute can be overridden to specify the regex for matching this ID (useful for capturing names instead of numeric IDs) and ``model_object_key`` can be overridden to specify the model field that will be matched against. Parents and URLs ---------------- Resources typically have a parent resource, of which the resource is a subclass. Resources will often list their children (by setting ``list_child_resources`` and ``item_child_resources`` in a subclass to lists of other WebAPIResource instances). This makes the entire tree navigatable. The URLs are built up automatically, so long as the result of get_url_patterns() from top-level resources are added to the Django url_patterns variables commonly found in urls.py. Child objects should set the ``model_parent_key`` variable to the field name of the object's parent in the resource hierarchy. This allows WebAPIResource to build a URL with the right values filled in in order to make a URL to this object. If the parent is dynamic based on certain conditions, then the ``get_parent_object`` function can be overridden instead. Object Serialization -------------------- Objects are serialized through the ``serialize_object`` function. This rarely needs to be overridden, but can be called from WebAPIEncoders in order to serialize the object. By default, this will loop through the ``fields`` variable and add each value to the resulting dictionary. Values can be specially serialized by creating functions in the form of ``serialize__field``. These functions take the object being serialized and must return a value that can be fed to the encoder. Handling Requests ----------------- WebAPIResource calls the following functions based on the type of HTTP request: * ``get`` - HTTP GET for individual objects. * ``get_list`` - HTTP GET for resources representing lists of objects. * ``create`` - HTTP POST on resources representing lists of objects. This is expected to return the object and an HTTP status of 201 CREATED, on success. * ``update`` - HTTP PUT on individual objects to modify their state based on full or partial data. * ``delete`` - HTTP DELETE on an individual object. This is expected to return a status of HTTP 204 No Content on success. The default implementation just deletes the object. Any function that is not implemented will return an HTTP 405 Method Not Allowed. Functions that have handlers provided should set ``allowed_methods`` to a tuple of the HTTP methods allowed. For example:: allowed_methods = ('GET', POST', 'DELETE') These functions are passed an HTTPRequest and a list of arguments captured in the URL and are expected to return standard HTTP response codes, along with a payload in most cases. The functions can return any of: * A HttpResponse * A WebAPIResponse * A WebAPIError * A tuple of (WebAPIError, Payload) * A tuple of (WebAPIError, Payload Dictionary, Headers Dictionary) * A tuple of (HTTP status, Payload) * A tuple of (HTTP status, Payload Dictionary, Headers Dictionary) In general, it's best to return one of the tuples containing an HTTP status, and not any object, but there are cases where an object is necessary. Commonly, a handler will need to fetch parent objects in order to make some request. The values for all captured object IDs in the URL are passed to the handler, but it's best to not use these directly. Instead, the handler should accept a **kwargs parameter, and then call the parent resource's ``get_object`` function and pass in that **kwargs. For example:: def create(self, request, *args, **kwargs): try: my_parent = myParentResource.get_object(request, *args, **kwargs) except ObjectDoesNotExist: return DOES_NOT_EXIST Expanding Resources ------------------- The resulting data returned from a resource will by default provide links to child resources. If a lot of aggregated data is needed, then instead of making several queries the caller can use the ``?expand=`` parameter. This takes a comma-separated list of keys in the resource names found in the payloads and expands them instead of linking to them. This can result in really large downloads, if deep expansion is made when accessing lists of resources. However, it can also result in less strain on the server if used correctly. Faking HTTP Methods ------------------- There are clients that can't actually request anything but HTTP POST and HTTP GET. An HTML form is one such example, and Flash applications are another. For these cases, an HTTP POST can be made, with a special ``_method`` parameter passed to the URL. This can be set to the HTTP method that's desired. For example, ``PUT`` or ``DELETE``. Permissions ----------- Unless overridden, an object cannot be modified, created, or deleted if the user is not logged in and if an appropriate permission function does not return True. These permission functions are: * ``has_access_permissions`` - Used for HTTP GET calls. Returns True by default. * ``has_modify_permissions`` - Used for HTTP POST or PUT calls, if called by the subclass. Returns False by default. * ``has_delete_permissions`` - Used for HTTP DELETE permissions. Returns False by default. Browser Caching --------------- To improve performance, resources can make use of browser-side caching. If a resource is accessed more than once, and it hasn't changed, the resource will return an :http:`304`. There are two methods for caching: Last Modified headers, and ETags. Last Modified ~~~~~~~~~~~~~ A resource can set ``last_modified_field`` to the name of a DateTimeField in the model. This will be used to determine if the resource has changed since the last request. If a bit more work is needed, the ``get_last_modified`` function can instead be overridden. This takes the request and object and is expected to return a timestamp. ETags ~~~~~ ETags are arbitrary, unique strings that represent the state of a resource. There should only ever be one possible ETag per state of the resource. A resource can set the ``etag_field`` to the name of a field in the model. If no field really works, ``autogenerate_etags`` can be set. This will generate a suitable ETag based on all fields in the resource. For this to work correctly, no custom data can be added to the payload, and links cannot be dynamic. If more work is needed, the ``get_etag`` function can instead be overridden. It will take a request and object and is expected to return a string. Mimetypes --------- Resources should list the possible mimetypes they'll accept and return in :py:attr:`allowed_list_mimetypes` (for resource lists) and :py:attr:`allowed_item_mimetypes` (for resource items and singletons). Entries in these lists are checked against the mimetypes requested in the HTTP Accept header, and, by default, the returned data will be sent in that mimetype. By default, these lists will contain :mimetype:`application/json` and :mimetype:`application/xml`, along with any resource-specific mimetypes, if used. Resource-specific Mimetypes ~~~~~~~~~~~~~~~~~~~~~~~~~~~ In order to better identify resources, resources can provide their own custom mimetypes. These are known as vendor-specific mimetypes, and are subsets of :mimetype:`application/json` and :mimetype:`application/xml`. An example would be :mimetype:`application/vnd.example.com.myresource+json`. To enable this on a resource, set :py:attr:`mimetype_vendor` to the vendor name. This is often a domain name. For example:: mimetype_vendor = 'djblets.org' The resource names will then be generated based on the name of the resource (:py:attr:`name_plural` for resource lists, :py:attr:`name` for resource items and singletons). These can be customized as well:: mimetype_list_resource_name = 'myresource-list' mimetype_item_resource_name = 'myresource' When these are used, any client requesting either the resource-specific mimetype or the more generic mimetype will by default receive a payload with the resource-specific mimetype. This makes it easier to identify the schema of resource data without hard-coding any knowledge of the URI. """ # Configuration model = None fields = {} uri_object_key_regex = '[0-9]+' uri_object_key = None model_object_key = 'pk' model_parent_key = None last_modified_field = None etag_field = None autogenerate_etags = False singleton = False list_child_resources = [] item_child_resources = [] allowed_methods = ('GET',) mimetype_vendor = None mimetype_list_resource_name = None mimetype_item_resource_name = None allowed_list_mimetypes = list(WebAPIResponse.supported_mimetypes) allowed_item_mimetypes = list(WebAPIResponse.supported_mimetypes) # State method_mapping = { 'GET': 'get', 'POST': 'post', 'PUT': 'put', 'DELETE': 'delete', } _parent_resource = None _mimetypes_cache = None def __init__(self): _name_to_resources[self.name] = self _name_to_resources[self.name_plural] = self _class_to_resources[self.__class__] = self if self.mimetype_vendor: self.allowed_item_mimetypes = list(self.allowed_item_mimetypes) self.allowed_list_mimetypes = list(self.allowed_list_mimetypes) # Add resource-specific versions of supported mimetypes for mimetypes, is_list in [(self.allowed_item_mimetypes, False), (self.allowed_list_mimetypes, True)]: for mimetype in WebAPIResponse.supported_mimetypes: if mimetype in mimetypes: mimetypes.append(self._build_resource_mimetype(mimetype, is_list)) @vary_on_headers('Accept', 'Cookie') def __call__(self, request, api_format=None, *args, **kwargs): """Invokes the correct HTTP handler based on the type of request.""" check_login(request) method = request.method if method == 'POST': # Not all clients can do anything other than GET or POST. # So, in the case of POST, we allow overriding the method # used. method = request.POST.get('_method', kwargs.get('_method', method)) elif method == 'PUT': # Normalize the PUT data so we can get to it. # This is due to Django's treatment of PUT vs. POST. They claim # that PUT, unlike POST, is not necessarily represented as form # data, so they do not parse it. However, that gives us no clean way # of accessing the data. So we pretend it's POST for a second in # order to parse. # # This must be done only for legitimate PUT requests, not faked # ones using ?method=PUT. try: request.method = 'POST' request._load_post_and_files() request.method = 'PUT' except AttributeError: request.META['REQUEST_METHOD'] = 'POST' request._load_post_and_files() request.META['REQUEST_METHOD'] = 'PUT' request._djblets_webapi_method = method request._djblets_webapi_kwargs = kwargs request.PUT = request.POST if method in self.allowed_methods: if (method == "GET" and not self.singleton and (self.uri_object_key is None or self.uri_object_key not in kwargs)): view = self.get_list else: view = getattr(self, self.method_mapping.get(method, None)) else: view = None if view and callable(view): result = view(request, api_format=api_format, *args, **kwargs) if isinstance(result, WebAPIResponse): return result elif isinstance(result, WebAPIError): return WebAPIResponseError( request, err=result, api_format=api_format, mimetype=self._build_error_mimetype(request)) elif isinstance(result, tuple): headers = {} if method == 'GET': request_params = request.GET else: request_params = request.POST if len(result) == 3: headers = result[2] if 'Location' in headers: extra_querystr = '&'.join([ '%s=%s' % (param, request_params[param]) for param in SPECIAL_PARAMS if param in request_params ]) if extra_querystr: if '?' in headers['Location']: headers['Location'] += '&' + extra_querystr else: headers['Location'] += '?' + extra_querystr if isinstance(result[0], WebAPIError): return WebAPIResponseError( request, err=result[0], headers=headers, extra_params=result[1], api_format=api_format, mimetype=self._build_error_mimetype(request)) else: return WebAPIResponse( request, status=result[0], obj=result[1], headers=headers, api_format=api_format, **self.build_response_args(request)) elif isinstance(result, HttpResponse): return result else: raise AssertionError(result) else: return HttpResponseNotAllowed(self.allowed_methods) @property def __name__(self): return self.__class__.__name__ @property def name(self): """Returns the name of the object, used for keys in the payloads.""" if self.model: return self.model.__name__.lower() else: return self.__name__.lower() @property def name_plural(self): """Returns the plural name of the object, used for lists.""" if self.singleton: return self.name else: return self.name + 's' @property def item_result_key(self): """Returns the key for single objects in the payload.""" return self.name @property def list_result_key(self): """Returns the key for lists of objects in the payload.""" return self.name_plural @property def uri_name(self): """Returns the name of the resource in the URI. This can be overridden when the name in the URI needs to differ from the name used for the resource. """ return self.name_plural.replace('_', '-') def _build_resource_mimetype(self, mimetype, is_list): if is_list: resource_name = self.mimetype_list_resource_name or \ self.name_plural.replace('_', '-') else: resource_name = self.mimetype_item_resource_name or \ self.name.replace('_', '-') return self._build_vendor_mimetype(mimetype, resource_name) def _build_error_mimetype(self, request): mimetype = get_http_requested_mimetype( request, WebAPIResponse.supported_mimetypes) if self.mimetype_vendor: mimetype = self._build_vendor_mimetype(mimetype, 'error') return mimetype def _build_vendor_mimetype(self, mimetype, name): parts = mimetype.split('/') return '%s/vnd.%s.%s+%s' % (parts[0], self.mimetype_vendor, name, parts[1]) def build_response_args(self, request): is_list = (request._djblets_webapi_method == 'GET' and not self.singleton and (self.uri_object_key is None or self.uri_object_key not in request._djblets_webapi_kwargs)) if is_list: supported_mimetypes = self.allowed_list_mimetypes else: supported_mimetypes = self.allowed_item_mimetypes mimetype = get_http_requested_mimetype(request, supported_mimetypes) if (self.mimetype_vendor and mimetype in WebAPIResponse.supported_mimetypes): mimetype = self._build_resource_mimetype(mimetype, is_list) return { 'supported_mimetypes': supported_mimetypes, 'mimetype': mimetype, } def get_object(self, request, *args, **kwargs): """Returns an object, given captured parameters from a URL. This will perform a query for the object, taking into account ``model_object_key``, ``uri_object_key``, and any captured parameters from the URL. This requires that ``model`` and ``uri_object_key`` be set. """ assert self.model assert self.singleton or self.uri_object_key queryset = self.get_queryset(request, *args, **kwargs).select_related() if self.singleton: return queryset.get() else: return queryset.get(**{ self.model_object_key: kwargs[self.uri_object_key] }) def post(self, *args, **kwargs): """Handles HTTP POSTs. This is not meant to be overridden unless there are specific needs. This will invoke ``create`` if doing an HTTP POST on a list resource. By default, an HTTP POST is not allowed on individual object resourcces. """ if 'POST' not in self.allowed_methods: return HttpResponseNotAllowed(self.allowed_methods) if (self.uri_object_key is None or kwargs.get(self.uri_object_key, None) is None): return self.create(*args, **kwargs) # Don't allow POSTs on children by default. allowed_methods = list(self.allowed_methods) allowed_methods.remove('POST') return HttpResponseNotAllowed(allowed_methods) def put(self, request, *args, **kwargs): """Handles HTTP PUTs. This is not meant to be overridden unless there are specific needs. This will just invoke ``update``. """ return self.update(request, *args, **kwargs) @webapi_response_errors(DOES_NOT_EXIST, NOT_LOGGED_IN, PERMISSION_DENIED) def get(self, request, api_format, *args, **kwargs): """Handles HTTP GETs to individual object resources. By default, this will check for access permissions and query for the object. It will then return a serialized form of the object. This may need to be overridden if needing more complex logic. """ if (not self.model or (self.uri_object_key is None and not self.singleton)): return HttpResponseNotAllowed(self.allowed_methods) try: obj = self.get_object(request, *args, **kwargs) except self.model.DoesNotExist: return DOES_NOT_EXIST if not self.has_access_permissions(request, obj, *args, **kwargs): if request.user.is_authenticated(): return PERMISSION_DENIED else: return NOT_LOGGED_IN last_modified_timestamp = self.get_last_modified(request, obj) if (last_modified_timestamp and get_modified_since(request, last_modified_timestamp)): return HttpResponseNotModified() etag = self.get_etag(request, obj) if etag and etag_if_none_match(request, etag): return HttpResponseNotModified() data = { self.item_result_key: self.serialize_object(obj, request=request, *args, **kwargs), } response = WebAPIResponse(request, status=200, obj=data, api_format=api_format, **self.build_response_args(request)) if last_modified_timestamp: set_last_modified(response, last_modified_timestamp) if etag: set_etag(response, etag) return response @webapi_request_fields( optional={ 'start': { 'type': int, 'description': 'The 0-based index of the first result in the ' 'list. The start index is usually the previous ' 'start index plus the number of previous ' 'results. By default, this is 0.', }, 'max-results': { 'type': int, 'description': 'The maximum number of results to return in ' 'this list. By default, this is 25.', } }, allow_unknown=True ) def get_list(self, request, *args, **kwargs): """Handles HTTP GETs to list resources. By default, this will query for a list of objects and return the list in a serialized form. """ data = { 'links': self.get_links(self.list_child_resources, request=request, *args, **kwargs), } if self.model: return WebAPIResponsePaginated( request, queryset=self.get_queryset(request, is_list=True, *args, **kwargs).select_related(), results_key=self.list_result_key, serialize_object_func = lambda obj: get_resource_for_object(obj).serialize_object( obj, request=request, *args, **kwargs), extra_data=data, **self.build_response_args(request)) else: return 200, data @webapi_login_required def create(self, request, api_format, *args, **kwargs): """Handles HTTP POST requests to list resources. This is used to create a new object on the list, given the data provided in the request. It should usually return HTTP 201 Created upon success. By default, this returns HTTP 405 Method Not Allowed. """ return HttpResponseNotAllowed(self.allowed_methods) @webapi_login_required def update(self, request, api_format, *args, **kwargs): """Handles HTTP PUT requests to object resources. This is used to update an object, given full or partial data provided in the request. It should usually return HTTP 200 OK upon success. By default, this returns HTTP 405 Method Not Allowed. """ return HttpResponseNotAllowed(self.allowed_methods) @webapi_login_required @webapi_response_errors(DOES_NOT_EXIST, NOT_LOGGED_IN, PERMISSION_DENIED) def delete(self, request, api_format, *args, **kwargs): """Handles HTTP DELETE requests to object resources. This is used to delete an object, if the user has permissions to do so. By default, this deletes the object and returns HTTP 204 No Content. """ if not self.model or self.uri_object_key is None: return HttpResponseNotAllowed(self.allowed_methods) try: obj = self.get_object(request, *args, **kwargs) except self.model.DoesNotExist: return DOES_NOT_EXIST if not self.has_delete_permissions(request, obj, *args, **kwargs): if request.user.is_authenticated(): return PERMISSION_DENIED else: return NOT_LOGGED_IN obj.delete() return 204, {} def get_queryset(self, request, is_list=False, *args, **kwargs): """Returns a queryset used for querying objects or lists of objects. This can be overridden to filter the object list, such as for hiding non-public objects. The ``is_list`` parameter can be used to specialize the query based on whether an individual object or a list of objects is being queried. """ return self.model.objects.all() def get_url_patterns(self): """Returns the Django URL patterns for this object and its children. This is used to automatically build up the URL hierarchy for all objects. Projects should call this for top-level resources and return them in the ``urls.py`` files. """ urlpatterns = never_cache_patterns('', url(r'^$', self, name=self._build_named_url(self.name_plural)), ) for resource in self.list_child_resources: resource._parent_resource = self child_regex = r'^' + resource.uri_name + '/' urlpatterns += patterns('', url(child_regex, include(resource.get_url_patterns())), ) if self.uri_object_key or self.singleton: # If the resource has particular items in it... if self.uri_object_key: base_regex = r'^(?P<%s>%s)/' % (self.uri_object_key, self.uri_object_key_regex) elif self.singleton: base_regex = r'^' urlpatterns += never_cache_patterns('', url(base_regex + '$', self, name=self._build_named_url(self.name)) ) for resource in self.item_child_resources: resource._parent_resource = self child_regex = base_regex + resource.uri_name + '/' urlpatterns += patterns('', url(child_regex, include(resource.get_url_patterns())), ) return urlpatterns def has_access_permissions(self, request, obj, *args, **kwargs): """Returns whether or not the user has read access to this object.""" return True def has_modify_permissions(self, request, obj, *args, **kwargs): """Returns whether or not the user can modify this object.""" return False def has_delete_permissions(self, request, obj, *args, **kwargs): """Returns whether or not the user can delete this object.""" return False def serialize_object(self, obj, *args, **kwargs): """Serializes the object into a Python dictionary.""" data = { 'links': self.get_links(self.item_child_resources, obj, *args, **kwargs), } request = kwargs.get('request', None) expand = request.GET.get('expand', request.POST.get('expand', '')) expanded_resources = expand.split(',') for field in list(self.fields): serialize_func = getattr(self, "serialize_%s_field" % field, None) if serialize_func and callable(serialize_func): value = serialize_func(obj) else: value = getattr(obj, field) if isinstance(value, models.Manager): value = value.all() elif isinstance(value, models.ForeignKey): value = value.get() expand_field = field in expanded_resources if isinstance(value, models.Model) and not expand_field: resource = get_resource_for_object(value) assert resource data['links'][field] = { 'method': 'GET', 'href': resource.get_href(value, *args, **kwargs), 'title': unicode(value), } elif isinstance(value, QuerySet) and not expand_field: data[field] = [ { 'method': 'GET', 'href': get_resource_for_object(o).get_href( o, *args, **kwargs), 'title': unicode(o), } for o in value.all() ] else: data[field] = value for resource_name in expanded_resources: if resource_name not in data['links']: continue # Try to find the resource from the child list. found = False for resource in self.item_child_resources: if resource_name in [resource.name, resource.name_plural]: found = True break if not found or not resource.model: continue del data['links'][resource_name] extra_kwargs = { self.uri_object_key: getattr(obj, self.model_object_key), } extra_kwargs.update(**kwargs) extra_kwargs.update(self.get_href_parent_ids(obj)) data[resource_name] = resource.get_queryset( is_list=True, *args, **extra_kwargs) return data def get_links(self, resources=[], obj=None, request=None, *args, **kwargs): """Returns a dictionary of links coming off this resource. The resulting links will point to the resources passed in ``resources``, and will also provide special resources for ``self`` (which points back to the official location for this resource) and one per HTTP method/operation allowed on this resource. """ links = {} base_href = None if obj: base_href = self.get_href(obj, request, *args, **kwargs) if not base_href: # We may have received None from the URL above. if request: base_href = request.build_absolute_uri() else: base_href = '' links['self'] = { 'method': 'GET', 'href': base_href, } # base_href without any query arguments. i = base_href.find('?') if i != -1: clean_base_href = base_href[:i] else: clean_base_href = base_href if 'POST' in self.allowed_methods and not obj: links['create'] = { 'method': 'POST', 'href': clean_base_href, } if 'PUT' in self.allowed_methods and obj: links['update'] = { 'method': 'PUT', 'href': clean_base_href, } if 'DELETE' in self.allowed_methods and obj: links['delete'] = { 'method': 'DELETE', 'href': clean_base_href, } for resource in resources: links[resource.name_plural] = { 'method': 'GET', 'href': '%s%s/' % (clean_base_href, resource.uri_name), } for key, info in self.get_related_links(obj, request, *args, **kwargs).iteritems(): links[key] = { 'method': info['method'], 'href': info['href'], } if 'title' in info: links[key]['title'] = info['title'] return links def get_related_links(self, obj=None, request=None, *args, **kwargs): """Returns links related to this resource. The result should be a dictionary of link names to a dictionary of information. The information should contain: * 'method' - The HTTP method * 'href' - The URL * 'title' - The title of the link (optional) * 'resource' - The WebAPIResource instance * 'list-resource' - True if this links to a list resource (optional) """ return {} def get_href(self, obj, request, *args, **kwargs): """Returns the URL for this object.""" if not self.uri_object_key: return None href_kwargs = { self.uri_object_key: getattr(obj, self.model_object_key), } href_kwargs.update(self.get_href_parent_ids(obj)) return request.build_absolute_uri( reverse(self._build_named_url(self.name), kwargs=href_kwargs)) def get_href_parent_ids(self, obj): """Returns a dictionary mapping parent object keys to their values for an object. """ parent_ids = {} if self._parent_resource and self.model_parent_key: parent_obj = self.get_parent_object(obj) parent_ids = self._parent_resource.get_href_parent_ids(parent_obj) if self._parent_resource.uri_object_key: parent_ids[self._parent_resource.uri_object_key] = \ getattr(parent_obj, self._parent_resource.model_object_key) return parent_ids def get_parent_object(self, obj): """Returns the parent of an object. By default, this uses ``model_parent_key`` to figure out the parent, but it can be overridden for more complex behavior. """ parent_obj = getattr(obj, self.model_parent_key) if isinstance(parent_obj, (models.Manager, models.ForeignKey)): parent_obj = parent_obj.get() return parent_obj def get_last_modified(self, request, obj): """Returns the last modified timestamp of an object. By default, this uses ``last_modified_field`` to determine what field in the model represents the last modified timestamp of the object. This can be overridden for more complex behavior. """ if self.last_modified_field: return getattr(obj, self.last_modified_field) return None def get_etag(self, request, obj): """Returns the ETag representing the state of the object. By default, this uses ``etag_field`` to determine what field in the model is unique enough to represent the state of the object. This can be overridden for more complex behavior. """ if self.etag_field: return unicode(getattr(obj, self.etag_field)) elif self.autogenerate_etags: return self.generate_etag(obj, self.fields) return None def generate_etag(self, obj, fields): """Generates an ETag from the serialized values of all given fields.""" values = [] for field in fields: serialize_func = getattr(self, "serialize_%s_field" % field, None) if serialize_func and callable(serialize_func): values.append(serialize_func(obj)) else: values.append(unicode(getattr(obj, field))) return sha1(':'.join(fields)).hexdigest() def _build_named_url(self, name): """Builds a Django URL name from the provided name.""" return '%s-resource' % name.replace('_', '-') class RootResource(WebAPIResource): """The root of a resource tree. This is meant to be instantiated with a list of immediate child resources. The result of ``get_url_patterns`` should be included in a project's ``urls.py``. """ name = 'root' singleton = True def __init__(self, child_resources=[], include_uri_templates=True): super(RootResource, self).__init__() self.list_child_resources = child_resources self._uri_templates = {} self._include_uri_templates = include_uri_templates def get_etag(self, request, obj, *args, **kwargs): return sha1('%s:%s' % (self._include_uri_templates, ':'.join(repr(self.list_child_resources)))).hexdigest() def get(self, request, *args, **kwargs): """ Retrieves the list of top-level resources, and a list of :term:`URI templates` for accessing any resource in the tree. """ etag = self.get_etag(request, None) if etag_if_none_match(request, etag): return HttpResponseNotModified() data = { 'links': self.get_links(self.list_child_resources, request=request, *args, **kwargs), } if self._include_uri_templates: data['uri_templates'] = self.get_uri_templates(request, *args, **kwargs) return 200, data, { 'ETag': etag, } def get_uri_templates(self, request, *args, **kwargs): """Returns all URI templates in the resource tree. REST APIs can be very chatty if a client wants to be well-behaved and crawl the resource tree asking for the links, instead of hard-coding the paths. The benefit is that they can keep from breaking when paths change. The downside is that it can take many HTTP requests to get the right resource. This list of all URI templates allows clients who know the resource name and the data they care about to simply plug them into the URI template instead of trying to crawl over the whole tree. This can make things far more efficient. """ if not self._uri_templates: self._uri_templates = {} base_href = request.build_absolute_uri() for name, href in self._walk_resources(self, base_href): self._uri_templates[name] = href return self._uri_templates def _walk_resources(self, resource, list_href): yield resource.name_plural, list_href for child in resource.list_child_resources: child_href = list_href + child.uri_name + '/' for name, href in self._walk_resources(child, child_href): yield name, href if resource.uri_object_key: object_href = '%s{%s}/' % (list_href, resource.uri_object_key) yield resource.name, object_href for child in resource.item_child_resources: child_href = object_href + child.uri_name + '/' for name, href in self._walk_resources(child, child_href): yield name, href class UserResource(WebAPIResource): """A default resource for representing a Django User model.""" model = User fields = { 'id': { 'type': int, 'description': 'The numeric ID of the user.', }, 'username': { 'type': str, 'description': "The user's username.", }, 'first_name': { 'type': str, 'description': "The user's first name.", }, 'last_name': { 'type': str, 'description': "The user's last name.", }, 'fullname': { 'type': str, 'description': "The user's full name (first and last).", }, 'email': { 'type': str, 'description': "The user's e-mail address", }, 'url': { 'type': str, 'description': "The URL to the user's page on the site. " "This is deprecated and will be removed in a " "future version.", }, } uri_object_key = 'username' uri_object_key_regex = '[A-Za-z0-9@\._-]+' model_object_key = 'username' autogenerate_etags = True allowed_methods = ('GET',) def serialize_fullname_field(self, user): return user.get_full_name() def serialize_url_field(self, user): return user.get_absolute_url() def has_modify_permissions(self, request, user, *args, **kwargs): """Returns whether or not the user can modify this object.""" return request.user.is_authenticated() and user.pk == request.user.pk @augment_method_from(WebAPIResource) def get_list(self, *args, **kwargs): """Retrieves the list of users on the site.""" pass class GroupResource(WebAPIResource): """A default resource for representing a Django Group model.""" model = Group fields = ('id', 'name') uri_object_key = 'group_name' uri_object_key_regex = '[A-Za-z0-9_-]+' model_object_key = 'name' autogenerate_etags = True allowed_methods = ('GET',) def register_resource_for_model(model, resource): """Registers a resource as the official location for a model. ``resource`` can be a callable function that takes an instance of ``model`` and returns a ``WebAPIResource``. """ _model_to_resources[model] = resource def get_resource_for_object(obj): """Returns the resource for an object.""" resource = _model_to_resources.get(obj.__class__, None) if not isinstance(resource, WebAPIResource) and callable(resource): resource = resource(obj) return resource def get_resource_from_name(name): """Returns the resource of the specified name.""" return _name_to_resources.get(name, None) def get_resource_from_class(klass): """Returns the resource with the specified resource class.""" return _class_to_resources.get(klass, None) def unregister_resource(resource): """Unregisters a resource from the caches.""" del _name_to_resources[resource.name] del _name_to_resources[resource.name_plural] del _class_to_resources[resource.__class__] user_resource = UserResource() group_resource = GroupResource() # These are good defaults, and will be overridden if another class calls # register_resource_for_model on these models. register_resource_for_model(User, user_resource) register_resource_for_model(Group, group_resource) djblets_0.7~git20120402.orig/djblets/webapi/errors.py0000644000175000017500000001030311746533534021005 0ustar diondion# # errors.py -- Error classes and codes for webapi # # Copyright (c) 2007-2009 Christian Hammond # Copyright (c) 2007-2009 David Trowbridge # # 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. # class WebAPIError(object): """ An API error, containing an error code and human readable message. """ def __init__(self, code, msg, http_status=400, headers={}): self.code = code self.msg = msg self.http_status = http_status self.headers = headers def with_message(self, msg): """ Overrides the default message for a WebAPIError with something more context specific. Example: return ENABLE_EXTENSION_FAILED.with_message('some error message') """ self.msg = msg return self WWW_AUTHENTICATE_HEADERS = { 'WWW-Authenticate': 'Basic realm="Web API"', } # # Standard error messages # NO_ERROR = WebAPIError(0, "If you see this, yell at the " "developers") SERVICE_NOT_CONFIGURED = WebAPIError(1, "The web service has not yet " "been configured", http_status=503) DOES_NOT_EXIST = WebAPIError(100, "Object does not exist", http_status=404) PERMISSION_DENIED = WebAPIError(101, "You don't have permission for this", http_status=403) INVALID_ATTRIBUTE = WebAPIError(102, "Invalid attribute", http_status=400) NOT_LOGGED_IN = WebAPIError(103, "You are not logged in", http_status=401, headers=WWW_AUTHENTICATE_HEADERS) LOGIN_FAILED = WebAPIError(104, "The username or password was " "not correct", http_status=401, headers=WWW_AUTHENTICATE_HEADERS) INVALID_FORM_DATA = WebAPIError(105, "One or more fields had errors", http_status=400) MISSING_ATTRIBUTE = WebAPIError(106, "Missing value for the attribute", http_status=400) ENABLE_EXTENSION_FAILED = WebAPIError(107, "There was a problem enabling " "the extension", http_status=500) # 500 Internal Server # Error DISABLE_EXTENSION_FAILED = WebAPIError(108, "There was a problem disabling " "the extension", http_status=500) # 500 Internal Server # Error djblets_0.7~git20120402.orig/djblets/webapi/encoders.py0000644000175000017500000000310011746533534021270 0ustar diondionfrom django.contrib.auth.models import User, Group from django.core.serializers.json import DjangoJSONEncoder from django.db.models.query import QuerySet from djblets.webapi.core import WebAPIEncoder class BasicAPIEncoder(WebAPIEncoder): """ A basic encoder that encodes dates, times, QuerySets, Users, and Groups. """ def encode(self, o, *args, **kwargs): if isinstance(o, QuerySet): return list(o) elif isinstance(o, User): return { 'id': o.id, 'username': o.username, 'first_name': o.first_name, 'last_name': o.last_name, 'fullname': o.get_full_name(), 'email': o.email, 'url': o.get_absolute_url(), } elif isinstance(o, Group): return { 'id': o.id, 'name': o.name, } else: try: return DjangoJSONEncoder().default(o) except TypeError: return None class ResourceAPIEncoder(WebAPIEncoder): """An encoder that encodes objects based on registered resources.""" def encode(self, o, *args, **kwargs): from djblets.webapi.resources import get_resource_for_object if isinstance(o, QuerySet): return list(o) resource = get_resource_for_object(o) if resource: return resource.serialize_object(o, *args, **kwargs) try: return DjangoJSONEncoder().default(o) except TypeError: return None djblets_0.7~git20120402.orig/djblets/webapi/decorators.py0000644000175000017500000002101211746533534021635 0ustar diondion# # decorators.py -- Decorators used for webapi views # # Copyright (c) 2007-2009 Christian Hammond # Copyright (c) 2007-2009 David Trowbridge # # 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. # from django.http import HttpRequest from djblets.util.decorators import simple_decorator from djblets.webapi.core import SPECIAL_PARAMS from djblets.webapi.errors import NOT_LOGGED_IN, PERMISSION_DENIED, \ INVALID_FORM_DATA def _find_httprequest(args): if isinstance(args[0], HttpRequest): request = args[0] else: # This should be in a class then. assert len(args) > 1 request = args[1] assert isinstance(request, HttpRequest) return request @simple_decorator def webapi(view_func): """Indicates that a view is a Web API handler.""" return view_func def webapi_response_errors(*errors): """Specifies the type of errors that the response may return. This can be used for generating documentation or schemas that cover the possible error responses of methods on a resource. """ def _dec(view_func): def _call(*args, **kwargs): return view_func(*args, **kwargs) _call.__name__ = view_func.__name__ _call.__doc__ = view_func.__doc__ _call.__dict__.update(view_func.__dict__) existing_errors = getattr(view_func, 'response_errors', set()) _call.response_errors = existing_errors.union(set(errors)) return _call return _dec @webapi_response_errors(NOT_LOGGED_IN) @simple_decorator def webapi_login_required(view_func): """ Checks that the user is logged in before invoking the view. If the user is not logged in, a NOT_LOGGED_IN error (HTTP 401 Unauthorized) is returned. """ def _checklogin(*args, **kwargs): request = _find_httprequest(args) if request.user.is_authenticated(): return view_func(*args, **kwargs) else: return NOT_LOGGED_IN view_func.login_required = True return _checklogin @webapi_response_errors(NOT_LOGGED_IN, PERMISSION_DENIED) def webapi_permission_required(perm): """ Checks that the user is logged in and has the appropriate permissions to access this view. A PERMISSION_DENIED error is returned if the user does not have the proper permissions. """ def _dec(view_func): def _checkpermissions(*args, **kwargs): request = _find_httprequest(args) if not request.user.is_authenticated(): response = NOT_LOGGED_IN elif not request.user.has_perm(perm): response = PERMISSION_DENIED else: response = view_func(*args, **kwargs) return response return _checkpermissions return _dec @webapi_response_errors(INVALID_FORM_DATA) def webapi_request_fields(required={}, optional={}, allow_unknown=False): """Validates incoming fields for a request. This is a helpful decorator for ensuring that the fields in the request match what the caller expects. If any field is set in the request that is not in either ``required`` or ``optional`` and ``allow_unknown`` is True, the response will be an INVALID_FORM_DATA error. The exceptions are the special fields ``method`` and ``callback``. If any field in ``required`` is not passed in the request, these will also be listed in the INVALID_FORM_DATA response. The ``required`` and ``optional`` parameters are dictionaries mapping field name to an info dictionary, which contains the following keys: * ``type`` - The data type for the field. * ```description`` - A description of the field. For example: @webapi_request_fields(required={ 'name': { 'type': str, 'description': 'The name of the object', } }) """ def _dec(view_func): def _validate(*args, **kwargs): request = _find_httprequest(args) if request.method == 'GET': request_fields = request.GET else: request_fields = request.POST invalid_fields = {} supported_fields = required.copy() supported_fields.update(optional) if not allow_unknown: for field_name in request_fields: if field_name in SPECIAL_PARAMS: # These are special names and can be ignored. continue if field_name not in supported_fields: invalid_fields[field_name] = ['Field is not supported'] for field_name, info in required.iteritems(): temp_fields = request_fields if info['type'] == file: temp_fields = request.FILES if temp_fields.get(field_name, None) is None: invalid_fields[field_name] = ['This field is required'] new_kwargs = kwargs.copy() for field_name, info in supported_fields.iteritems(): if isinstance(info['type'], file): continue value = request_fields.get(field_name, None) if value is not None: if type(info['type']) in (list, tuple): # This is a multiple-choice. Make sure the value is # valid. choices = info['type'] if value not in choices: invalid_fields[field_name] = [ "'%s' is not a valid value. Valid values " "are: %s" % ( value, ', '.join(["'%s'" % choice for choice in choices]) ) ] else: try: if issubclass(info['type'], bool): value = value in (1, "1", True, "True", "true") elif issubclass(info['type'], int): try: value = int(value) except ValueError: invalid_fields[field_name] = [ "'%s' is not an integer" % value ] except TypeError: # The field isn't a class type. This is a # coding error on the developer's side. raise TypeError("%s is not a valid field type" % info['type']) new_kwargs[field_name] = value if invalid_fields: return INVALID_FORM_DATA, { 'fields': invalid_fields, } return view_func(*args, **new_kwargs) _validate.__name__ = view_func.__name__ _validate.__doc__ = view_func.__doc__ _validate.__dict__.update(view_func.__dict__) _validate.required_fields = required.copy() _validate.optional_fields = optional.copy() if hasattr(view_func, 'required_fields'): _validate.required_fields.update(view_func.required_fields) if hasattr(view_func, 'optional_fields'): _validate.optional_fields.update(view_func.optional_fields) return _validate return _dec djblets_0.7~git20120402.orig/djblets/webapi/core.py0000644000175000017500000003326511746533534020435 0ustar diondion# # core.py -- Core classes for webapi # # Copyright (c) 2007-2009 Christian Hammond # Copyright (c) 2007-2009 David Trowbridge # # 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. # from cStringIO import StringIO from xml.sax.saxutils import XMLGenerator from django.conf import settings from django.http import HttpResponse from django.utils import simplejson from django.utils.encoding import force_unicode from djblets.util.http import get_http_requested_mimetype, is_mimetype_a from djblets.webapi.errors import INVALID_FORM_DATA SPECIAL_PARAMS = ('api_format', 'callback', '_method', 'expand') class WebAPIEncoder(object): """ Encodes an object into a dictionary of fields and values. This object is used for both JSON and XML API formats. Projects can subclass this to provide representations of their objects. To make use of a encoder, add the path to the encoder class to the project's settings.WEB_API_ENCODERS list. For example: WEB_API_ENCODERS = ( 'myproject.webapi.MyEncoder', ) """ def encode(self, o, *args, **kwargs): """ Encodes an object. This is expected to return either a dictionary or a list. If the object being encoded is not supported, return None, or call the superclass's encode method. """ return None class JSONEncoderAdapter(simplejson.JSONEncoder): """ Adapts a WebAPIEncoder to be used with simplejson. This takes an existing encoder and makes it available to use as a simplejson.JSONEncoder. This is used internally when generating JSON from a WebAPIEncoder, but can be used in other projects for more specific purposes as well. """ def __init__(self, encoder, *args, **kwargs): simplejson.JSONEncoder.__init__(self, *args, **kwargs) self.encoder = encoder def encode(self, o, *args, **kwargs): self.encode_args = args self.encode_kwargs = kwargs return super(JSONEncoderAdapter, self).encode(o) def default(self, o): """ Encodes an object using the supplied WebAPIEncoder. If the encoder is unable to encode this object, a TypeError is raised. """ result = self.encoder.encode(o, *self.encode_args, **self.encode_kwargs) if result is None: raise TypeError("%r is not JSON serializable" % (o,)) return result class XMLEncoderAdapter(object): """ Adapts a WebAPIEncoder to output XML. This takes an existing encoder and adapts it to output a simple XML format. """ def __init__(self, encoder, *args, **kwargs): self.encoder = encoder def encode(self, o, *args, **kwargs): self.level = 0 self.doIndent = False stream = StringIO() self.xml = XMLGenerator(stream, settings.DEFAULT_CHARSET) self.xml.startDocument() self.startElement("rsp") self.__encode(o, *args, **kwargs) self.endElement("rsp") self.xml.endDocument() self.xml = None return stream.getvalue() def __encode(self, o, *args, **kwargs): if isinstance(o, dict): for key, value in o.iteritems(): attrs = {} if isinstance(key, (int, long)): attrs['value'] = str(key) key = 'int' self.startElement(key, attrs) self.__encode(value, *args, **kwargs) self.endElement(key) elif isinstance(o, (tuple, list)): self.startElement("array") for i in o: self.startElement("item") self.__encode(i, *args, **kwargs) self.endElement("item") self.endElement("array") elif isinstance(o, basestring): self.text(o) elif isinstance(o, (int, long)): self.text("%d" % o) elif isinstance(o, bool): if o: self.text("True") else: self.text("False") elif o is None: pass else: result = self.encoder.encode(o, *args, **kwargs) if result is None: raise TypeError("%r is not XML serializable" % (o,)) return self.__encode(result, *args, **kwargs) def startElement(self, name, attrs={}): self.addIndent() self.xml.startElement(name, attrs) self.level += 1 self.doIndent = True def endElement(self, name): self.level -= 1 self.addIndent() self.xml.endElement(name) self.doIndent = True def text(self, value): self.xml.characters(value) self.doIndent = False def addIndent(self): if self.doIndent: self.xml.ignorableWhitespace('\n' + ' ' * self.level) class WebAPIResponse(HttpResponse): """ An API response, formatted for the desired file format. """ supported_mimetypes = [ 'application/json', 'application/xml', ] def __init__(self, request, obj={}, stat='ok', api_format=None, status=200, headers={}, encoders=[], mimetype=None, supported_mimetypes=None): if not api_format: if request.method == 'GET': api_format = request.GET.get('api_format', None) else: api_format = request.POST.get('api_format', None) if not supported_mimetypes: supported_mimetypes = self.supported_mimetypes if not mimetype: if not api_format: mimetype = get_http_requested_mimetype(request, supported_mimetypes) elif api_format == "json": mimetype = 'application/json' elif api_format == "xml": mimetype = 'application/xml' if not mimetype: self.status_code = 400 self.content_set = True return if not request.is_ajax() and request.FILES: # When uploading a file using AJAX to a webapi view, # we must set the mimetype to text/plain. If we use # application/json instead, the browser will ask the user # to save the file. It's not great, but it's what we must do. mimetype = 'text/plain' super(WebAPIResponse, self).__init__(mimetype=mimetype, status=status) self.request = request self.callback = request.GET.get('callback', None) self.api_data = {'stat': stat} self.api_data.update(obj) self.content_set = False self.mimetype = mimetype self.encoders = encoders or get_registered_encoders() for header, value in headers.iteritems(): self[header] = value def _get_content(self): """ Returns the API response content in the appropriate format. This is an overridden version of HttpResponse._get_content that generates the resulting content when requested, rather than generating it up-front in the constructor. This is used so that the @webapi decorator can set the appropriate API format before the content is generated, but after the response is created. """ class MultiEncoder(WebAPIEncoder): def __init__(self, encoders): self.encoders = encoders def encode(self, *args, **kwargs): for encoder in self.encoders: result = encoder.encode(*args, **kwargs) if result is not None: return result return None if not self.content_set: adapter = None encoder = MultiEncoder(self.encoders) # See the note above about the check for text/plain. if (self.mimetype == 'text/plain' or is_mimetype_a(self.mimetype, 'application/json')): adapter = JSONEncoderAdapter(encoder) elif is_mimetype_a(self.mimetype, "application/xml"): adapter = XMLEncoderAdapter(encoder) else: assert False content = adapter.encode(self.api_data, request=self.request) if self.callback != None: content = "%s(%s);" % (self.callback, content) self.content = content self.content_set = True return super(WebAPIResponse, self)._get_content() def _set_content(self, value): super(WebAPIResponse, self)._set_content(value) content = property(_get_content, _set_content) class WebAPIResponsePaginated(WebAPIResponse): """ A response containing a list of results with pagination. This accepts the following parameters to the URL: * start - The index of the first item (0-based index). * max-results - The maximum number of results to return in the request. """ def __init__(self, request, queryset, results_key="results", prev_key="prev", next_key="next", total_results_key="total_results", default_max_results=25, max_results_cap=200, serialize_object_func=None, extra_data={}, *args, **kwargs): try: start = int(request.GET.get('start', 0)) except ValueError: start = 0 try: max_results = \ min(int(request.GET.get('max-results', default_max_results)), max_results_cap) except ValueError: max_results = default_max_results results = queryset[start:start + max_results] if serialize_object_func: results = [serialize_object_func(obj) for obj in results] else: results = list(results) total_results = queryset.count() data = { results_key: results, total_results_key: total_results, } data.update(extra_data) full_path = request.build_absolute_uri(request.path) if start > 0: data['links'][prev_key] = { 'method': 'GET', 'href': '%s?start=%s&max-results=%s' % (full_path, max(start - max_results, 0), max_results), } if start + len(results) < total_results: data['links'][next_key] = { 'method': 'GET', 'href': '%s?start=%s&max-results=%s' % (full_path, start + max_results, max_results), } WebAPIResponse.__init__(self, request, obj=data, *args, **kwargs) class WebAPIResponseError(WebAPIResponse): """ A general error response, containing an error code and a human-readable message. """ def __init__(self, request, err, extra_params={}, headers={}, *args, **kwargs): errdata = { 'err': { 'code': err.code, 'msg': err.msg } } errdata.update(extra_params) headers = headers.copy() headers.update(err.headers) WebAPIResponse.__init__(self, request, obj=errdata, stat="fail", status=err.http_status, headers=headers, *args, **kwargs) class WebAPIResponseFormError(WebAPIResponseError): """ An error response class designed to return all errors from a form class. """ def __init__(self, request, form, *args, **kwargs): fields = {} for field in form.errors: fields[field] = [force_unicode(e) for e in form.errors[field]] WebAPIResponseError.__init__(self, request, INVALID_FORM_DATA, { 'fields': fields }, *args, **kwargs) __registered_encoders = None def get_registered_encoders(): """ Returns a list of registered Web API encoders. """ global __registered_encoders if __registered_encoders is None: __registered_encoders = [] encoders = getattr(settings, 'WEB_API_ENCODERS', ['djblets.webapi.encoders.BasicAPIEncoder']) for encoder in encoders: encoder_path = encoder.split('.') if len(encoder_path) > 1: encoder_module_name = '.'.join(encoder_path[:-1]) else: encoder_module_name = '.' encoder_module = __import__(encoder_module_name, {}, {}, encoder_path[-1]) encoder_class = getattr(encoder_module, encoder_path[-1]) __registered_encoders.append(encoder_class()) return __registered_encoders # Backwards-compatibility # # This must be done after the classes in order to avoid a # circular import problem. from djblets.webapi.encoders import BasicAPIEncoder djblets_0.7~git20120402.orig/djblets/webapi/auth.py0000644000175000017500000000664511746533534020450 0ustar diondion# # auth.py -- Authentication helpers for webapi # # Copyright (c) 2007-2009 Christian Hammond # Copyright (c) 2007-2009 David Trowbridge # # 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. # import logging from django.contrib import auth from django.views.decorators.http import require_POST from djblets.webapi.core import WebAPIResponse, WebAPIResponseError from djblets.webapi.decorators import webapi from djblets.webapi.errors import LOGIN_FAILED def check_login(request): """Checks if a login request was made. If the client specifies a HTTP_AUTHORIZATION header, this will attempt to authenticate using a supported authentication method. """ if 'HTTP_AUTHORIZATION' in request.META: basic_access_login(request) def basic_access_login(request): try: realm, encoded_auth = request.META['HTTP_AUTHORIZATION'].split(' ') username, password = encoded_auth.decode('base64').split(':', 1) except ValueError: logging.warning("Failed to parse HTTP_AUTHORIZATION header %s" % request.META['HTTP_AUTHORIZATION'], exc_info=1) return if realm != 'Basic': return # Don't authenticate if a user is already logged in and the # username matches. # # Note that this does mean that a new password will fail. However, # the user is already logged in, and querying the backend for every # request is excessive, so it's a tradeoff. The user already has access # to the server at this point anyway. if request.user.is_anonymous() or request.user.username != username: logging.debug("Attempting authentication on API for user %s" % username) user = auth.authenticate(username=username, password=password) if user and user.is_active: auth.login(request, user) else: logging.debug("API Login failed. No valid user found.") auth.logout(request) @require_POST @webapi def account_login(request, *args, **kwargs): username = request.POST.get('username', None) password = request.POST.get('password', None) user = auth.authenticate(username=username, password=password) if not user or not user.is_active: return WebAPIResponseError(request, LOGIN_FAILED) auth.login(request, user) return WebAPIResponse(request) @webapi def account_logout(request, *args, **kwargs): auth.logout(request) return WebAPIResponse(request) djblets_0.7~git20120402.orig/djblets/webapi/__init__.py0000644000175000017500000000000011746533534021221 0ustar diondiondjblets_0.7~git20120402.orig/djblets/util/0000755000175000017500000000000011746533534016630 5ustar diondiondjblets_0.7~git20120402.orig/djblets/util/tests.py0000644000175000017500000003210211746533534020342 0ustar diondion# # tests.py -- Unit tests for classes in djblets.util # # Copyright (c) 2007-2009 Christian Hammond # Copyright (c) 2007-2009 David Trowbridge # # 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. import datetime import unittest from django.contrib.sites.models import Site from django.core.cache import cache from django.http import HttpRequest from django.template import Token, TOKEN_TEXT, TemplateSyntaxError from django.utils.html import strip_spaces_between_tags from djblets.util.http import get_http_accept_lists, \ get_http_requested_mimetype, \ is_mimetype_a from djblets.util.misc import cache_memoize, CACHE_CHUNK_SIZE from djblets.util.testing import TestCase, TagTest from djblets.util.templatetags import djblets_deco from djblets.util.templatetags import djblets_email from djblets.util.templatetags import djblets_utils def normalize_html(s): return strip_spaces_between_tags(s).strip() class CacheTest(TestCase): def test_cache_memoize(self): """Testing cache_memoize""" cacheKey = "abc123" testStr = "Test 123" def cacheFunc(cacheCalled=[]): self.assertTrue(not cacheCalled) cacheCalled.append(True) return testStr result = cache_memoize(cacheKey, cacheFunc) self.assertEqual(result, testStr) # Call a second time. We should only call cacheFunc once. result = cache_memoize(cacheKey, cacheFunc) self.assertEqual(result, testStr) def test_cache_memoize_large_files(self): """Testing cache_memoize with large files""" cacheKey = "abc123" # This takes into account the size of the pickle data, and will # get us to exactly 2 chunks of data in cache. data = 'x' * (CACHE_CHUNK_SIZE * 2 - 8) def cacheFunc(cacheCalled=[]): self.assertTrue(not cacheCalled) cacheCalled.append(True) return data result = cache_memoize(cacheKey, cacheFunc, large_data=True, compress_large_data=False) self.assertEqual(result, data) site = Site.objects.get_current() full_key = '%s:%s' % (site.domain, cacheKey) self.assertTrue(cache.has_key(full_key)) self.assertTrue(cache.has_key('%s-0' % full_key)) self.assertTrue(cache.has_key('%s-1' % full_key)) self.assertFalse(cache.has_key('%s-2' % full_key)) result = cache_memoize(cacheKey, cacheFunc, large_data=True, compress_large_data=False) self.assertEqual(result, data) class BoxTest(TagTest): def testPlain(self): """Testing box tag""" node = djblets_deco.box(self.parser, Token(TOKEN_TEXT, 'box')) context = {} self.assertEqual(normalize_html(node.render(context)), '
' + '
\ncontent\n ' + '
') def testClass(self): """Testing box tag (with extra class)""" node = djblets_deco.box(self.parser, Token(TOKEN_TEXT, 'box "class"')) context = {} self.assertEqual(normalize_html(node.render(context)), '
' + '
\ncontent\n ' + '
') def testError(self): """Testing box tag (invalid usage)""" self.assertRaises(TemplateSyntaxError, lambda: djblets_deco.box(self.parser, Token(TOKEN_TEXT, 'box "class" "foo"'))) class ErrorBoxTest(TagTest): def testPlain(self): """Testing errorbox tag""" node = djblets_deco.errorbox(self.parser, Token(TOKEN_TEXT, 'errorbox')) context = {} self.assertEqual(normalize_html(node.render(context)), '
\ncontent\n
') def testId(self): """Testing errorbox tag (with id)""" node = djblets_deco.errorbox(self.parser, Token(TOKEN_TEXT, 'errorbox "id"')) context = {} self.assertEqual(normalize_html(node.render(context)), '
\ncontent\n
') def testError(self): """Testing errorbox tag (invalid usage)""" self.assertRaises(TemplateSyntaxError, lambda: djblets_deco.errorbox(self.parser, Token(TOKEN_TEXT, 'errorbox "id" ' + '"foo"'))) class HttpTest(TestCase): def setUp(self): self.request = HttpRequest() self.request.META['HTTP_ACCEPT'] = \ 'application/json;q=0.5,application/xml,text/plain;q=0.0,*/*;q=0.0' def test_http_accept_lists(self): """Testing djblets.http.get_http_accept_lists""" acceptable_mimetypes, unacceptable_mimetypes = \ get_http_accept_lists(self.request) self.assertEqual(acceptable_mimetypes, ['application/xml', 'application/json']) self.assertEqual(unacceptable_mimetypes, ['text/plain', '*/*']) def test_get_requested_mimetype_with_supported_mimetype(self): """Testing djblets.http.get_requested_mimetype with supported mimetype""" self.assertEqual( get_http_requested_mimetype(self.request, ['foo/bar', 'application/json']), 'application/json') self.assertEqual( get_http_requested_mimetype(self.request, ['application/xml']), 'application/xml') self.assertEqual( get_http_requested_mimetype(self.request, ['application/json', 'application/xml']), 'application/xml') def test_get_requested_mimetype_with_no_consensus(self): """Testing djblets.http.get_requested_mimetype with no consensus between client and server""" self.request = HttpRequest() self.request.META['HTTP_ACCEPT'] = 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8' self.assertEqual( get_http_requested_mimetype(self.request, ['application/json', 'application/x-foo']), 'application/json') def test_get_requested_mimetype_with_wildcard_supported_mimetype(self): """Testing djblets.http.get_requested_mimetype with supported */* mimetype""" self.request = HttpRequest() self.request.META['HTTP_ACCEPT'] = '*/*' self.assertEqual( get_http_requested_mimetype(self.request, ['application/json', 'application/xml']), 'application/json') def test_get_requested_mimetype_with_unsupported_mimetype(self): """Testing djblets.http.get_requested_mimetype with unsupported mimetype""" self.assertEqual( get_http_requested_mimetype(self.request, ['text/plain']), None) self.assertEqual( get_http_requested_mimetype(self.request, ['foo/bar']), None) def test_is_mimetype_a(self): """Testing djblets.util.http.is_mimetype_a""" self.assertTrue(is_mimetype_a('application/json', 'application/json')) self.assertTrue(is_mimetype_a('application/vnd.foo+json', 'application/json')) self.assertFalse(is_mimetype_a('application/xml', 'application/json')) self.assertFalse(is_mimetype_a('foo/vnd.bar+json', 'application/json')) class AgeIdTest(TagTest): def setUp(self): TagTest.setUp(self) self.now = datetime.datetime.utcnow() self.context = { 'now': self.now, 'minus1': self.now - datetime.timedelta(1), 'minus2': self.now - datetime.timedelta(2), 'minus3': self.now - datetime.timedelta(3), 'minus4': self.now - datetime.timedelta(4), } def testNow(self): """Testing ageid tag (now)""" self.assertEqual(djblets_utils.ageid(self.now), 'age1') def testMinus1(self): """Testing ageid tag (yesterday)""" self.assertEqual(djblets_utils.ageid(self.now - datetime.timedelta(1)), 'age2') def testMinus2(self): """Testing ageid tag (two days ago)""" self.assertEqual(djblets_utils.ageid(self.now - datetime.timedelta(2)), 'age3') def testMinus3(self): """Testing ageid tag (three days ago)""" self.assertEqual(djblets_utils.ageid(self.now - datetime.timedelta(3)), 'age4') def testMinus4(self): """Testing ageid tag (four days ago)""" self.assertEqual(djblets_utils.ageid(self.now - datetime.timedelta(4)), 'age5') def testNotDateTime(self): """Testing ageid tag (non-datetime object)""" class Foo: def __init__(self, now): self.day = now.day self.month = now.month self.year = now.year self.assertEqual(djblets_utils.ageid(Foo(self.now)), 'age1') class TestEscapeSpaces(unittest.TestCase): def test(self): """Testing escapespaces filter""" self.assertEqual(djblets_utils.escapespaces('Hi there'), 'Hi there') self.assertEqual(djblets_utils.escapespaces('Hi there'), 'Hi  there') self.assertEqual(djblets_utils.escapespaces('Hi there\n'), 'Hi  there
') class TestHumanizeList(unittest.TestCase): def test0(self): """Testing humanize_list filter (length 0)""" self.assertEqual(djblets_utils.humanize_list([]), '') def test1(self): """Testing humanize_list filter (length 1)""" self.assertEqual(djblets_utils.humanize_list(['a']), 'a') def test2(self): """Testing humanize_list filter (length 2)""" self.assertEqual(djblets_utils.humanize_list(['a', 'b']), 'a and b') def test3(self): """Testing humanize_list filter (length 3)""" self.assertEqual(djblets_utils.humanize_list(['a', 'b', 'c']), 'a, b and c') def test4(self): """Testing humanize_list filter (length 4)""" self.assertEqual(djblets_utils.humanize_list(['a', 'b', 'c', 'd']), 'a, b, c, and d') class TestIndent(unittest.TestCase): def test(self): """Testing indent filter""" self.assertEqual(djblets_utils.indent('foo'), ' foo') self.assertEqual(djblets_utils.indent('foo', 3), ' foo') self.assertEqual(djblets_utils.indent('foo\nbar'), ' foo\n bar') class QuotedEmailTagTest(TagTest): def testInvalid(self): """Testing quoted_email tag (invalid usage)""" self.assertRaises(TemplateSyntaxError, lambda: djblets_email.quoted_email(self.parser, Token(TOKEN_TEXT, 'quoted_email'))) class CondenseTagTest(TagTest): def getContentText(self): return "foo\nbar\n\n\n\n\n\n\nfoobar!" def testPlain(self): """Testing condense tag""" node = djblets_email.condense(self.parser, Token(TOKEN_TEXT, 'condense')) self.assertEqual(node.render({}), "foo\nbar\n\n\nfoobar!") class QuoteTextFilterTest(unittest.TestCase): def testPlain(self): """Testing quote_text filter (default level)""" self.assertEqual(djblets_email.quote_text("foo\nbar"), "> foo\n> bar") def testLevel2(self): """Testing quote_text filter (level 2)""" self.assertEqual(djblets_email.quote_text("foo\nbar", 2), "> > foo\n> > bar") djblets_0.7~git20120402.orig/djblets/util/testing.py0000644000175000017500000000261511746533534020663 0ustar diondion# # testing.py -- Some classes useful for unit testing django-based applications # # Copyright (c) 2007-2010 Christian Hammond # Copyright (c) 2007-2010 David Trowbridge # # 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. # from djblets.testing.testcases import StubNodeList, StubParser, \ TagTest, TestCase __all__ = ['StubNodeList', 'StubParser', 'TagTest', 'TestCase'] djblets_0.7~git20120402.orig/djblets/util/templatetags/0000755000175000017500000000000011746533534021322 5ustar diondiondjblets_0.7~git20120402.orig/djblets/util/templatetags/djblets_utils.py0000644000175000017500000002063711746533534024553 0ustar diondion# # djblets_utils.py -- Various utility template tags # # Copyright (c) 2007-2009 Christian Hammond # Copyright (c) 2007-2009 David Trowbridge # # 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. import datetime import os from django import template from django.template import TemplateSyntaxError from django.template.defaultfilters import stringfilter from django.template.loader import render_to_string from django.utils.safestring import mark_safe from django.utils.timezone import is_aware from djblets.util.decorators import basictag, blocktag from djblets.util.dates import get_tz_aware_utcnow register = template.Library() @register.tag @blocktag def definevar(context, nodelist, varname): """ Defines a variable in the context based on the contents of the block. This is useful when you need to reuse the results of some tag logic multiple times in a template or in a blocktrans tag. """ context[varname] = nodelist.render(context) return "" @register.tag @blocktag def ifuserorperm(context, nodelist, user, perm): """ Renders content depending on whether the logged in user is the specified user or has the specified permission. This is useful when you want to restrict some code to the owner of a review request or to a privileged user that has the abilities of the owner. Example:: {% ifuserorperm myobject.user "myobject.can_change_status" %} Owner-specific content here... {% endifuserorperm %} """ if _check_userorperm(context, user, perm): return nodelist.render(context) return '' @register.tag @blocktag def ifnotuserandperm(context, nodelist, user, perm): """ The opposite of ifuserorperm. Renders content if the logged in user is not the specified user and doesn't have the specified permission. Example:: {% ifuserorperm myobject.user "myobject.can_change_status" %} Owner-specific content here... {% endifuserorperm %} {% ifnotuserandperm myobject.user "myobject.can_change_status" %} Another owner-specific content here... {% endifnotuserandperm %} """ if not _check_userorperm(context, user, perm): return nodelist.render(context) return '' def _check_userorperm(context, user, perm): req_user = context.get('user', None) return user == req_user or req_user.has_perm(perm) @register.tag @basictag(takes_context=True) def include_as_string(context, template_name): s = render_to_string(template_name, context) s = s.replace("'", "\\'") s = s.replace("\n", "\\\n") return "'%s'" % s @register.tag @blocktag def attr(context, nodelist, attrname): """ Sets an HTML attribute to a value if the value is not an empty string. """ content = nodelist.render(context) if content.strip() == "": return "" return ' %s="%s"' % (attrname, content) @register.filter def escapespaces(value): """ HTML-escapes all spaces with `` `` and newlines with ``
``. """ return value.replace(' ', '  ').replace('\n', '
') @register.simple_tag def ageid(timestamp): """ Returns an ID based on the difference between a timestamp and the current time. The ID is returned based on the following differences in days: ========== ==== Difference ID ========== ==== 0 age1 1 age2 2 age3 3 age4 4 or more age5 ========== ==== """ if timestamp is None: return "" # Convert datetime.date into datetime.datetime if timestamp.__class__ is not datetime.datetime: timestamp = datetime.datetime(timestamp.year, timestamp.month, timestamp.day) now = datetime.datetime.utcnow() if is_aware(timestamp): now = get_tz_aware_utcnow() delta = now - (timestamp - datetime.timedelta(0, 0, timestamp.microsecond)) if delta.days == 0: return "age1" elif delta.days == 1: return "age2" elif delta.days == 2: return "age3" elif delta.days == 3: return "age4" else: return "age5" @register.filter def user_displayname(user): """ Returns the display name of the user. If the user has a full name set, it will display this. Otherwise, it will display the username. """ return user.get_full_name() or user.username @register.filter def humanize_list(value): """ Humanizes a list of values, inserting commands and "and" where appropriate. ========================= ====================== Example List Resulting string ========================= ====================== ``["a"]`` ``"a"`` ``["a", "b"]`` ``"a and b"`` ``["a", "b", "c"]`` ``"a, b and c"`` ``["a", "b", "c", "d"]`` ``"a, b, c, and d"`` ========================= ====================== """ if len(value) == 0: return "" elif len(value) == 1: return value[0] s = ", ".join(value[:-1]) if len(value) > 3: s += "," return "%s and %s" % (s, value[-1]) @register.filter def contains(container, value): """ Returns True if the specified value is in the specified container. """ return value in container @register.filter def getitem(container, value): """ Returns the attribute of a specified name from a container. """ return container[value] @register.filter def exclude_item(container, item): """ Excludes an item from a list. """ if isinstance(container, list): container = list(container) if item in container: container.remove(item) else: raise TemplateSyntaxError, "remove_item expects a list" return container @register.filter def indent(value, numspaces=4): """ Indents a string by the specified number of spaces. """ indent_str = " " * numspaces return indent_str + value.replace("\n", "\n" + indent_str) @register.filter def basename(value): """ Returns the basename of a path. """ return os.path.basename(value) @register.filter(name="range") def range_filter(value): """ Turns an integer into a range of numbers. This is useful for iterating with the "for" tag. For example: {% for i in 10|range %} {{i}} {% endfor %} """ return range(value) @register.filter def realname(user): """ Returns the real name of a user, if available, or the username. If the user has a full name set, this will return the full name. Otherwise, this returns the username. """ full_name = user.get_full_name() if full_name == '': return user.username else: return full_name @register.filter @stringfilter def startswith(value1, value2): """ Returns true if value1 starts with value2. """ return value1.startswith(value2) @register.filter @stringfilter def endswith(value1, value2): """Returns true if value1 ends with value2.""" return value1.endswith(value2) @register.filter @stringfilter def paragraphs(text): """ Adds

...

tags around blocks of text in a string. This expects that each paragraph in the string will be on its own line. Blank lines are filtered out. """ s = "" for line in text.splitlines(): if line: s += "

%s

\n" % line return mark_safe(s) paragraphs.is_safe = True djblets_0.7~git20120402.orig/djblets/util/templatetags/djblets_js.py0000644000175000017500000000372311746533534024024 0ustar diondion# # djblets_js.py -- JavaScript-related template tags # # Copyright (c) 2007-2009 Christian Hammond # Copyright (c) 2007-2009 David Trowbridge # # 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. from django import template register = template.Library() @register.simple_tag def form_dialog_fields(form): """ Translates a Django Form object into a JavaScript list of fields. The resulting list of fields can be used to represent the form dynamically. """ s = '' for field in form: s += "{ name: '%s', " % field.name if field.is_hidden: s += "hidden: true, " else: s += "label: '%s', " % field.label_tag(field.label + ":") if field.field.required: s += "required: true, " if field.field.help_text: s += "help_text: '%s', " % field.field.help_text s += "widget: '%s' }," % unicode(field) # Chop off the last ',' return "[ %s ]" % s[:-1] djblets_0.7~git20120402.orig/djblets/util/templatetags/djblets_images.py0000644000175000017500000001015311746533534024650 0ustar diondion# # djblets_images.py -- Image-related template tags # # Copyright (c) 2007-2009 Christian Hammond # Copyright (c) 2007-2009 David Trowbridge # # 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. import logging import os import tempfile try: from cStringIO import StringIO except ImportError: from StringIO import StringIO try: from PIL import Image except ImportError: import Image from django import template from django.core.files import File register = template.Library() @register.simple_tag def crop_image(file, x, y, width, height): """ Crops an image at the specified coordinates and dimensions, returning the resulting URL of the cropped image. """ filename = file.name storage = file.storage basename = filename if filename.find(".") != -1: basename = filename.rsplit('.', 1)[0] new_name = '%s_%d_%d_%d_%d.png' % (basename, x, y, width, height) if not storage.exists(new_name): try: file = storage.open(filename) data = StringIO(file.read()) file.close() image = Image.open(data) image = image.crop((x, y, x + width, y + height)) (fd, filename) = tempfile.mkstemp() file = os.fdopen(fd, 'w+b') image.save(file, 'png') file.close() file = File(open(filename, 'rb')) storage.save(new_name, file) file.close() os.unlink(filename) except (IOError, KeyError), e: logging.error('Error cropping image file %s at %d, %d, %d, %d ' 'and saving as %s: %s' % (filename, x, y, width, height, new_name, e), exc_info=1) return "" return storage.url(new_name) # From http://www.djangosnippets.org/snippets/192 @register.filter def thumbnail(file, size='400x100'): """ Creates a thumbnail of an image with the specified size, returning the URL of the thumbnail. """ x, y = [int(x) for x in size.split('x')] filename = file.name if filename.find(".") != -1: basename, format = filename.rsplit('.', 1) miniature = '%s_%s.%s' % (basename, size, format) else: basename = filename miniature = '%s_%s' % (basename, size) storage = file.storage if not storage.exists(miniature): try: file = storage.open(filename, 'rb') data = StringIO(file.read()) file.close() image = Image.open(data) image.thumbnail([x, y], Image.ANTIALIAS) (fd, filename) = tempfile.mkstemp() file = os.fdopen(fd, 'w+b') image.save(file, image.format) file.close() file = File(open(filename, 'rb')) storage.save(miniature, file) file.close() os.unlink(filename) except (IOError, KeyError), e: logging.error('Error thumbnailing image file %s and saving ' 'as %s: %s' % (filename, miniature, e), exc_info=1) return "" return storage.url(miniature) djblets_0.7~git20120402.orig/djblets/util/templatetags/djblets_forms.py0000644000175000017500000000524511746533534024537 0ustar diondion# # djblets_forms.py -- Form-related template tags # # Copyright (c) 2008-2009 Christian Hammond # # 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. from django import template from django.forms import BooleanField from django.utils.encoding import force_unicode from django.utils.html import escape register = template.Library() @register.simple_tag def label_tag(field): """ Outputs the tag for a field's label. This gives more fine-grained control over the appearance of the form. This exists because a template can't access this directly from a field in newforms. """ is_checkbox = is_field_checkbox(field) s = '