I'm going to type out loud for a little bit. I'm hoping to better
define the problem so we can think about solutions more clearly (or go
find ones as solved by other frameworks).
Django has the concept of an application, a reusable chunk of
functionality which can be reused in many different projects. A
project is a collection of applications.
A project is responsible for defining which apps are available
(INSTALLED_APPS), and what URL the app can be accessed under, e.g.,
(r'^admin/', include('django.contrib.admin.urls.admin')).
== Problem ==
If application Foo wishes to link to application Admin, it must know
how the Project has 'mapped' the Admin application (e.g., starts with
/admin/).
This leads in to the original topic of the thread, which centers around
encasulating URLs; gathering their RE and their 'parameters' into one
class for reuse.
== Problem ==
If application Foo wishes to link to application Admin, it must know
how the URL is constructed.
So what does the solution look like?
== 1 ==
Application Foo should be able to use a Class, function, whatever,
supplied by the Admin application, to obtain a URL it can draw in an
HTML page.
== 2 ==
The Admin application should know something about how it has been
deployed by the project to that it can correctly construct a URL to
itself.
== v0.01 Solution ==
INSTALLED_APPS = (
('django.contrib.admin', 'admin',),
('cpt.app.foo', 'foo',),
)
When the framework/project installs an application using this
configuration, it could add a well known variable to the
django.contrib.admin package called 'DEPLOYMENT_PREFIX'.
I don't have a proposal on how to get that variable into the urls.py
module under the project. I haven't thought it through and would
rather skip it for now.
As far as encasulating URLs inside an application, the convention might
be to have a urls.py module which could hold Classes defining URLs. A
URL class might look like this:
class StartWorkflowURL:
"""Defines a bogus URL for testing.
"""
_RE = r'^workflows/foo/(?P<init_param>\d+)/'
_init_param = 0
def __init__(self, init_param=0):
"""URL to a workflow.
"""
self._init_param = init_param
def RE(self):
return self._regex
def url(self):
return '%s/workflows/foo/%d/' % (DEPLOYMENT_PREFIX, self._bar)
The Class RE method allows the RE to be included in urlpatterns:
urlpatterns = patterns('',
(StartWorkflowURL().RE(), 'start_workflow'),
)
I know that this definition could be improved upon (it may not even be
valid Python). There's probably a more 'pythonic' way (I'm a Java guy
who thinks in classes still). But the idea is that if you want to link
to the Admin application, you ask the Admin application to tell you
how.
All right. That's enough for now. Don't know if anyone is interested
in dissecting this, but I thought I'd get it out there as an idea. Not
a proposal, suggestion, or anything else. Just an idea.
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"Django users" group.
To post to this group, send email to django-users@googlegroups.com
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at
http://groups.google.com/group/django-users
-~----------~----~----~----~------~----~------~--~---
