"""URL Helpers"""
# Last synced with Rails copy at Revision 6070 on Feb 8th, 2007.
import re
import urllib
from routes import url_for, request_config
import tags
from asset_tag import compute_public_path
from javascript import *
from webhelpers.util import html_escape
def get_url(url):
if callable(url):
return url()
else:
return url
def url(*args, **kargs):
"""
Lazily evaluates url_for() arguments.
Used instead of url_for() for functions so that the function will be
evaluated in a lazy manner rather than at initial function call.
"""
args = args
kargs = kargs
def call():
return url_for(*args, **kargs)
return call
def link_to(name, url='', **html_options):
"""
Create link tag with text ``name`` and a URL created by the set of ``options``.
See the valid options in the documentation for Routes url_for.
The html_options has three special features. One for creating
javascript confirm alerts where if you pass ``confirm='Are you sure?'``,
the link will be guarded with a JS popup asking that question. If
the user accepts, the link is processed, otherwise not.
Another for creating a popup window, which is done by either passing
``popup`` with True or the options of the window in Javascript form.
And a third for making the link do a POST request (instead of the
regular GET) through a dynamically added form element that is
instantly submitted. Note that if the user has turned off Javascript,
the request will fall back on the GET. So its your responsibility to
determine what the action should be once it arrives at the controller.
The POST form is turned on by passing ``post`` as True. Note, it's
not possible to use POST requests and popup targets at the same time
(an exception will be thrown).
Examples::
>> link_to("Delete this page", url(action="destroy", id=4), confirm="Are you sure?")
>> link_to("Help", url(action="help"), popup=True)
>> link_to("Busy loop", url(action="busy"), popup=['new_window', 'height=300,width=600'])
>> link_to("Destroy account", url(action="destroy"), confirm="Are you sure?", method='delete')
"""
if html_options:
html_options = convert_options_to_javascript(**html_options)
tag_op = tags.tag_options(**html_options)
else:
tag_op = ''
if callable(url):
url = url()
else:
url = html_escape(url)
return "%s" % (url, tag_op, name or url)
def button_to(name, url='', **html_options):
"""
Generate a form containing a sole button that submits to ``url``.
Use this method instead of ``link_to`` for actions that do not have
the safe HTTP GET semantics implied by using a hypertext link.
The parameters are the same as for ``link_to``. Any ``html_options``
that you pass will be applied to the inner ``input`` element. In
particular, pass
disabled = True/False
as part of ``html_options`` to control whether the button is
disabled. The generated form element is given the class
'button-to', to which you can attach CSS styles for display
purposes.
The submit button itself will be displayed as an image if you
provide both ``type`` and ``src`` as followed:
type='image', src='icon_delete.gif'
The ``src`` path will be computed as the image_tag() computes its
``source`` argument.
Example 1::
# inside of controller for "feeds"
>> button_to("Edit", url(action='edit', id=3))
Example 2::
>> button_to("Destroy", url(action='destroy', id=3), confirm="Are you sure?", method='DELETE')
Example 3::
# Button as an image.
>> button_to("Edit", url(action='edit', id=3), type='image', src='icon_delete.gif')
*NOTE*: This method generates HTML code that represents a form.
Forms are "block" content, which means that you should not try to
insert them into your HTML where only inline content is expected.
For example, you can legally insert a form inside of a ``div`` or
``td`` element or in between ``p`` elements, but not in the middle
of a run of text, nor can you place a form within another form.
(Bottom line: Always validate your HTML before going public.)
"""
button_html = _button_to(name, url, **html_options)
return '%s' % (button_html)
def _button_to(name, url='', **html_options):
"""
Creates the button_to html but leaves out the to allow the secure_button_to()
(webhelpers.rails.secure_form_tag.secure_button_to) to use this function as well.
"""
if html_options:
convert_boolean_attributes(html_options, ['disabled'])
method_tag = ''
method = html_options.pop('method', '')
if method.upper() in ['PUT', 'DELETE']:
method_tag = tags.tag('input', type_='hidden', id='_method', name_='_method',
value=method)
form_method = (method.upper() == 'GET' and method) or 'POST'
confirm = html_options.get('confirm')
if confirm:
del html_options['confirm']
html_options['onclick'] = "return %s;" % confirm_javascript_function(confirm)
if callable(url):
ur = url()
url, name = ur, name or tags.escape_once(ur)
else:
url, name = url, name or url
submit_type = html_options.get('type')
img_source = html_options.get('src')
if submit_type == 'image' and img_source:
html_options.update(dict(type=submit_type, value=name,
alt=html_options.get('alt', name)))
html_options['src'] = compute_public_path(img_source, 'images', 'png')
else:
html_options.update(dict(type='submit', value=name))
return """