django.contrib.admindocs.views: 214 total statements, 0.0% covered

Generated: Wed 2013-03-13 10:33 CET

Source file: /media/Envs/Envs/filer-gallery/lib/python2.7/site-packages/django/contrib/admindocs/views.py

Stats: 0 executed, 197 missed, 17 excluded, 168 ignored

  1. import inspect
  2. import os
  3. import re
  4. from django import template
  5. from django.template import RequestContext
  6. from django.conf import settings
  7. from django.contrib.admin.views.decorators import staff_member_required
  8. from django.db import models
  9. from django.shortcuts import render_to_response
  10. from django.core.exceptions import ImproperlyConfigured, ViewDoesNotExist
  11. from django.http import Http404
  12. from django.core import urlresolvers
  13. from django.contrib.admindocs import utils
  14. from django.contrib.sites.models import Site
  15. from django.utils.importlib import import_module
  16. from django.utils.translation import ugettext as _
  17. from django.utils.safestring import mark_safe
  18. # Exclude methods starting with these strings from documentation
  19. MODEL_METHODS_EXCLUDE = ('_', 'add_', 'delete', 'save', 'set_')
  20. class GenericSite(object):
  21. domain = 'example.com'
  22. name = 'my site'
  23. @staff_member_required
  24. def doc_index(request):
  25. if not utils.docutils_is_available:
  26. return missing_docutils_page(request)
  27. return render_to_response('admin_doc/index.html', {
  28. 'root_path': urlresolvers.reverse('admin:index'),
  29. }, context_instance=RequestContext(request))
  30. @staff_member_required
  31. def bookmarklets(request):
  32. admin_root = urlresolvers.reverse('admin:index')
  33. return render_to_response('admin_doc/bookmarklets.html', {
  34. 'root_path': admin_root,
  35. 'admin_url': mark_safe("%s://%s%s" % (request.is_secure() and 'https' or 'http', request.get_host(), admin_root)),
  36. }, context_instance=RequestContext(request))
  37. @staff_member_required
  38. def template_tag_index(request):
  39. if not utils.docutils_is_available:
  40. return missing_docutils_page(request)
  41. load_all_installed_template_libraries()
  42. tags = []
  43. app_libs = template.libraries.items()
  44. builtin_libs = [(None, lib) for lib in template.builtins]
  45. for module_name, library in builtin_libs + app_libs:
  46. for tag_name, tag_func in library.tags.items():
  47. title, body, metadata = utils.parse_docstring(tag_func.__doc__)
  48. if title:
  49. title = utils.parse_rst(title, 'tag', _('tag:') + tag_name)
  50. if body:
  51. body = utils.parse_rst(body, 'tag', _('tag:') + tag_name)
  52. for key in metadata:
  53. metadata[key] = utils.parse_rst(metadata[key], 'tag', _('tag:') + tag_name)
  54. if library in template.builtins:
  55. tag_library = None
  56. else:
  57. tag_library = module_name.split('.')[-1]
  58. tags.append({
  59. 'name': tag_name,
  60. 'title': title,
  61. 'body': body,
  62. 'meta': metadata,
  63. 'library': tag_library,
  64. })
  65. return render_to_response('admin_doc/template_tag_index.html', {
  66. 'root_path': urlresolvers.reverse('admin:index'),
  67. 'tags': tags
  68. }, context_instance=RequestContext(request))
  69. @staff_member_required
  70. def template_filter_index(request):
  71. if not utils.docutils_is_available:
  72. return missing_docutils_page(request)
  73. load_all_installed_template_libraries()
  74. filters = []
  75. app_libs = template.libraries.items()
  76. builtin_libs = [(None, lib) for lib in template.builtins]
  77. for module_name, library in builtin_libs + app_libs:
  78. for filter_name, filter_func in library.filters.items():
  79. title, body, metadata = utils.parse_docstring(filter_func.__doc__)
  80. if title:
  81. title = utils.parse_rst(title, 'filter', _('filter:') + filter_name)
  82. if body:
  83. body = utils.parse_rst(body, 'filter', _('filter:') + filter_name)
  84. for key in metadata:
  85. metadata[key] = utils.parse_rst(metadata[key], 'filter', _('filter:') + filter_name)
  86. if library in template.builtins:
  87. tag_library = None
  88. else:
  89. tag_library = module_name.split('.')[-1]
  90. filters.append({
  91. 'name': filter_name,
  92. 'title': title,
  93. 'body': body,
  94. 'meta': metadata,
  95. 'library': tag_library,
  96. })
  97. return render_to_response('admin_doc/template_filter_index.html', {
  98. 'root_path': urlresolvers.reverse('admin:index'),
  99. 'filters': filters
  100. }, context_instance=RequestContext(request))
  101. @staff_member_required
  102. def view_index(request):
  103. if not utils.docutils_is_available:
  104. return missing_docutils_page(request)
  105. if settings.ADMIN_FOR:
  106. settings_modules = [import_module(m) for m in settings.ADMIN_FOR]
  107. else:
  108. settings_modules = [settings]
  109. views = []
  110. for settings_mod in settings_modules:
  111. urlconf = import_module(settings_mod.ROOT_URLCONF)
  112. view_functions = extract_views_from_urlpatterns(urlconf.urlpatterns)
  113. if Site._meta.installed:
  114. site_obj = Site.objects.get(pk=settings_mod.SITE_ID)
  115. else:
  116. site_obj = GenericSite()
  117. for (func, regex) in view_functions:
  118. views.append({
  119. 'full_name': '%s.%s' % (func.__module__, getattr(func, '__name__', func.__class__.__name__)),
  120. 'site_id': settings_mod.SITE_ID,
  121. 'site': site_obj,
  122. 'url': simplify_regex(regex),
  123. })
  124. return render_to_response('admin_doc/view_index.html', {
  125. 'root_path': urlresolvers.reverse('admin:index'),
  126. 'views': views
  127. }, context_instance=RequestContext(request))
  128. @staff_member_required
  129. def view_detail(request, view):
  130. if not utils.docutils_is_available:
  131. return missing_docutils_page(request)
  132. mod, func = urlresolvers.get_mod_func(view)
  133. try:
  134. view_func = getattr(import_module(mod), func)
  135. except (ImportError, AttributeError):
  136. raise Http404
  137. title, body, metadata = utils.parse_docstring(view_func.__doc__)
  138. if title:
  139. title = utils.parse_rst(title, 'view', _('view:') + view)
  140. if body:
  141. body = utils.parse_rst(body, 'view', _('view:') + view)
  142. for key in metadata:
  143. metadata[key] = utils.parse_rst(metadata[key], 'model', _('view:') + view)
  144. return render_to_response('admin_doc/view_detail.html', {
  145. 'root_path': urlresolvers.reverse('admin:index'),
  146. 'name': view,
  147. 'summary': title,
  148. 'body': body,
  149. 'meta': metadata,
  150. }, context_instance=RequestContext(request))
  151. @staff_member_required
  152. def model_index(request):
  153. if not utils.docutils_is_available:
  154. return missing_docutils_page(request)
  155. m_list = [m._meta for m in models.get_models()]
  156. return render_to_response('admin_doc/model_index.html', {
  157. 'root_path': urlresolvers.reverse('admin:index'),
  158. 'models': m_list
  159. }, context_instance=RequestContext(request))
  160. @staff_member_required
  161. def model_detail(request, app_label, model_name):
  162. if not utils.docutils_is_available:
  163. return missing_docutils_page(request)
  164. # Get the model class.
  165. try:
  166. app_mod = models.get_app(app_label)
  167. except ImproperlyConfigured:
  168. raise Http404(_("App %r not found") % app_label)
  169. model = None
  170. for m in models.get_models(app_mod):
  171. if m._meta.object_name.lower() == model_name:
  172. model = m
  173. break
  174. if model is None:
  175. raise Http404(_("Model %(model_name)r not found in app %(app_label)r") % {'model_name': model_name, 'app_label': app_label})
  176. opts = model._meta
  177. # Gather fields/field descriptions.
  178. fields = []
  179. for field in opts.fields:
  180. # ForeignKey is a special case since the field will actually be a
  181. # descriptor that returns the other object
  182. if isinstance(field, models.ForeignKey):
  183. data_type = field.rel.to.__name__
  184. app_label = field.rel.to._meta.app_label
  185. verbose = utils.parse_rst((_("the related `%(app_label)s.%(data_type)s` object") % {'app_label': app_label, 'data_type': data_type}), 'model', _('model:') + data_type)
  186. else:
  187. data_type = get_readable_field_data_type(field)
  188. verbose = field.verbose_name
  189. fields.append({
  190. 'name': field.name,
  191. 'data_type': data_type,
  192. 'verbose': verbose,
  193. 'help_text': field.help_text,
  194. })
  195. # Gather many-to-many fields.
  196. for field in opts.many_to_many:
  197. data_type = field.rel.to.__name__
  198. app_label = field.rel.to._meta.app_label
  199. verbose = _("related `%(app_label)s.%(object_name)s` objects") % {'app_label': app_label, 'object_name': data_type}
  200. fields.append({
  201. 'name': "%s.all" % field.name,
  202. "data_type": 'List',
  203. 'verbose': utils.parse_rst(_("all %s") % verbose , 'model', _('model:') + opts.module_name),
  204. })
  205. fields.append({
  206. 'name' : "%s.count" % field.name,
  207. 'data_type' : 'Integer',
  208. 'verbose' : utils.parse_rst(_("number of %s") % verbose , 'model', _('model:') + opts.module_name),
  209. })
  210. # Gather model methods.
  211. for func_name, func in model.__dict__.items():
  212. if (inspect.isfunction(func) and len(inspect.getargspec(func)[0]) == 1):
  213. try:
  214. for exclude in MODEL_METHODS_EXCLUDE:
  215. if func_name.startswith(exclude):
  216. raise StopIteration
  217. except StopIteration:
  218. continue
  219. verbose = func.__doc__
  220. if verbose:
  221. verbose = utils.parse_rst(utils.trim_docstring(verbose), 'model', _('model:') + opts.module_name)
  222. fields.append({
  223. 'name': func_name,
  224. 'data_type': get_return_data_type(func_name),
  225. 'verbose': verbose,
  226. })
  227. # Gather related objects
  228. for rel in opts.get_all_related_objects() + opts.get_all_related_many_to_many_objects():
  229. verbose = _("related `%(app_label)s.%(object_name)s` objects") % {'app_label': rel.opts.app_label, 'object_name': rel.opts.object_name}
  230. accessor = rel.get_accessor_name()
  231. fields.append({
  232. 'name' : "%s.all" % accessor,
  233. 'data_type' : 'List',
  234. 'verbose' : utils.parse_rst(_("all %s") % verbose , 'model', _('model:') + opts.module_name),
  235. })
  236. fields.append({
  237. 'name' : "%s.count" % accessor,
  238. 'data_type' : 'Integer',
  239. 'verbose' : utils.parse_rst(_("number of %s") % verbose , 'model', _('model:') + opts.module_name),
  240. })
  241. return render_to_response('admin_doc/model_detail.html', {
  242. 'root_path': urlresolvers.reverse('admin:index'),
  243. 'name': '%s.%s' % (opts.app_label, opts.object_name),
  244. 'summary': _("Fields on %s objects") % opts.object_name,
  245. 'description': model.__doc__,
  246. 'fields': fields,
  247. }, context_instance=RequestContext(request))
  248. @staff_member_required
  249. def template_detail(request, template):
  250. templates = []
  251. for site_settings_module in settings.ADMIN_FOR:
  252. settings_mod = import_module(site_settings_module)
  253. if Site._meta.installed:
  254. site_obj = Site.objects.get(pk=settings_mod.SITE_ID)
  255. else:
  256. site_obj = GenericSite()
  257. for dir in settings_mod.TEMPLATE_DIRS:
  258. template_file = os.path.join(dir, template)
  259. templates.append({
  260. 'file': template_file,
  261. 'exists': os.path.exists(template_file),
  262. 'contents': lambda: os.path.exists(template_file) and open(template_file).read() or '',
  263. 'site_id': settings_mod.SITE_ID,
  264. 'site': site_obj,
  265. 'order': list(settings_mod.TEMPLATE_DIRS).index(dir),
  266. })
  267. return render_to_response('admin_doc/template_detail.html', {
  268. 'root_path': urlresolvers.reverse('admin:index'),
  269. 'name': template,
  270. 'templates': templates,
  271. }, context_instance=RequestContext(request))
  272. ####################
  273. # Helper functions #
  274. ####################
  275. def missing_docutils_page(request):
  276. """Display an error message for people without docutils"""
  277. return render_to_response('admin_doc/missing_docutils.html')
  278. def load_all_installed_template_libraries():
  279. # Load/register all template tag libraries from installed apps.
  280. for module_name in template.get_templatetags_modules():
  281. mod = import_module(module_name)
  282. try:
  283. libraries = [
  284. os.path.splitext(p)[0]
  285. for p in os.listdir(os.path.dirname(mod.__file__))
  286. if p.endswith('.py') and p[0].isalpha()
  287. ]
  288. except OSError:
  289. libraries = []
  290. for library_name in libraries:
  291. try:
  292. lib = template.get_library(library_name)
  293. except template.InvalidTemplateLibrary, e:
  294. pass
  295. def get_return_data_type(func_name):
  296. """Return a somewhat-helpful data type given a function name"""
  297. if func_name.startswith('get_'):
  298. if func_name.endswith('_list'):
  299. return 'List'
  300. elif func_name.endswith('_count'):
  301. return 'Integer'
  302. return ''
  303. def get_readable_field_data_type(field):
  304. """Returns the description for a given field type, if it exists,
  305. Fields' descriptions can contain format strings, which will be interpolated
  306. against the values of field.__dict__ before being output."""
  307. return field.description % field.__dict__
  308. def extract_views_from_urlpatterns(urlpatterns, base=''):
  309. """
  310. Return a list of views from a list of urlpatterns.
  311. Each object in the returned list is a two-tuple: (view_func, regex)
  312. """
  313. views = []
  314. for p in urlpatterns:
  315. if hasattr(p, 'url_patterns'):
  316. try:
  317. patterns = p.url_patterns
  318. except ImportError:
  319. continue
  320. views.extend(extract_views_from_urlpatterns(patterns, base + p.regex.pattern))
  321. elif hasattr(p, 'callback'):
  322. try:
  323. views.append((p.callback, base + p.regex.pattern))
  324. except ViewDoesNotExist:
  325. continue
  326. else:
  327. raise TypeError(_("%s does not appear to be a urlpattern object") % p)
  328. return views
  329. named_group_matcher = re.compile(r'\(\?P(<\w+>).+?\)')
  330. non_named_group_matcher = re.compile(r'\(.*?\)')
  331. def simplify_regex(pattern):
  332. """
  333. Clean up urlpattern regexes into something somewhat readable by Mere Humans:
  334. turns something like "^(?P<sport_slug>\w+)/athletes/(?P<athlete_slug>\w+)/$"
  335. into "<sport_slug>/athletes/<athlete_slug>/"
  336. """
  337. # handle named groups first
  338. pattern = named_group_matcher.sub(lambda m: m.group(1), pattern)
  339. # handle non-named groups
  340. pattern = non_named_group_matcher.sub("<var>", pattern)
  341. # clean up any outstanding regex-y characters.
  342. pattern = pattern.replace('^', '').replace('$', '').replace('?', '').replace('//', '/').replace('\\', '')
  343. if not pattern.startswith('/'):
  344. pattern = '/' + pattern
  345. return pattern