* Make SubMapper objects nestable and add route-generation helpers.

* Add SubMapper-based collections

* Make the deprecated Mapper.minimization False (disabled) by default

Release 1.11 (September 28, 2009)

=================================

* Extensive documentation rewrite.

    url.current(month=4)  =>  "/archives/2005/4/4"

    url.current()         =>  "/archives/2005/10/4"

Generation-only routes (aka. static routes)

-------------------------------------------

Minimization was a misfeature which was intended to save typing, but which

often resulted in the wrong route being chosen.  Old applications that still

Without minimization, the URL must contain values for all path variables in

the route::

    """

    def __init__(self, controller_scan=controller_scan, directory=None, 

        """Create a new Mapper instance

        All keyword arguments are optional.

            >>> map.extend(routes, path_prefix='/subapp')

            >>> len(map.matchlist) == 3

            True

            True

        .. note::

    def test_dynamic_with_default(self):

        for path in ['hi/:action', 'hi/:(action)']:

            m.minimization = True

            m.connect(path)

            eq_('/hi', m.generate())

    def test_dynamic_with_false_equivs(self):

        m.minimization = True

        m.connect('article/:page', page=False)

        m.connect(':controller/:action/:id')

        eq_('/view/None/chicago', m.generate(home=None, area='chicago'))

    def test_dynamic_with_underscore_parts(self):

        m.minimization = True

        m.connect('article/:small_page', small_page=False)

        m.connect(':(controller)/:(action)/:(id)')

        eq_('/article/hobbes', m.generate(small_page='hobbes'))

    def test_dynamic_with_false_equivs_and_splits(self):

        m.minimization = True

        m.connect('article/:(page)', page=False)

        m.connect(':(controller)/:(action)/:(id)')

    def test_dynamic_with_default_and_regexp_condition(self):

        for path in ['hi/:action', 'hi/:(action)']:

            m.minimization = True

            m.connect(path, requirements = {'action':'[a-z]+'})

    def test_standard_route(self):

        for path in [':controller/:action/:id', ':(controller)/:(action)/:(id)']:

            m.minimization = True

            m.connect(path)

            eq_('/admin/user/show/10', m.generate(controller='admin/user', action='show', id='10'))

    def test_multiroute(self):

        m.minimization = True

        m.connect('archive/:year/:month/:day', controller='blog', action='view', month=None, day=None,

                            requirements={'month':'\d{1,2}','day':'\d{1,2}'})

        eq_('/viewpost/3', m.generate(controller='post', action='view', id=3))

    def test_multiroute_with_splits(self):

        m.minimization = True

        m.connect('archive/:(year)/:(month)/:(day)', controller='blog', action='view', month=None, day=None,

                            requirements={'month':'\d{1,2}','day':'\d{1,2}'})

        eq_('/viewpost/3', m.generate(controller='post', action='view', id=3))

    def test_big_multiroute(self):

        m.minimization = True

        m.connect('', controller='articles', action='index')

        m.connect('admin', controller='admin/general', action='index')

        eq_(None, m.generate(controller='articles', action='find_by_date', year=2004))

    def test_big_multiroute_with_splits(self):

        m.minimization = True

        m.connect('', controller='articles', action='index')

        m.connect('admin', controller='admin/general', action='index')

        eq_(None, m.generate(controller='articles', action='find_by_date', year=2004))

    def test_big_multiroute_with_nomin(self):

        m.minimization = False

        m.connect('', controller='articles', action='index')

        m.connect('admin', controller='admin/general', action='index')

            eq_('/pages/joe', m.generate(controller='page', action='view', title='joe'))

    def test_extras(self):

        m.minimization = True

        m.connect('viewpost/:id', controller='post', action='view')

        m.connect(':controller/:action/:id')

        eq_('/viewpost/2?extra=3', m.generate(controller='post', action='view', id=2, extra=3))

    def test_extras_with_splits(self):

        m.minimization = True

        m.connect('viewpost/:(id)', controller='post', action='view')

        m.connect(':(controller)/:(action)/:(id)')

            eq_('/content', m.generate(controller='content'))

    def test_route_with_fixnum_default(self):

        m.minimization = True

        m.connect('page/:id', controller='content', action='show_page', id=1)

        m.connect(':controller/:action/:id')

        eq_('/content/show', m.generate(controller='content', action='show'))

    def test_route_with_fixnum_default_with_splits(self):

        m.minimization = True

        m.connect('page/:(id)', controller='content', action='show_page', id =1)

        m.connect(':(controller)/:(action)/:(id)')

    def test_uppercase_recognition(self):

        for path in [':controller/:action/:id', ':(controller)/:(action)/:(id)']:

            m.minimization = True

            m.connect(path)

            eq_('/Admin/NewsFeed', m.generate(controller='Admin/NewsFeed', action='index'))

    def test_backwards(self):

        m.minimization = True

        m.connect('page/:id/:action', controller='pages', action='show')

        m.connect(':controller/:action/:id')

        eq_('/pages/boo', m.generate(controller='pages', action='boo'))

    def test_backwards_with_splits(self):

        m.minimization = True

        m.connect('page/:(id)/:(action)', controller='pages', action='show')

        m.connect(':(controller)/:(action)/:(id)')

        eq_('/', m.generate(controller='content'))

    def test_url_with_prefix(self):

        m.minimization = True

        m.prefix = '/blog'

        m.connect(':controller/:action/:id')

        eq_('/blog/admin/comments', m.generate(controller='admin/comments'))

    def test_url_with_prefix_deeper(self):

        m.minimization = True

        m.prefix = '/blog/phil'

        m.connect(':controller/:action/:id')

        eq_('/blog/phil/admin/comments', m.generate(controller='admin/comments'))

    def test_url_with_environ_empty(self):

        m.minimization = True

        m.environ = dict(SCRIPT_NAME='')

        m.connect(':controller/:action/:id')

        eq_('/admin/comments', m.generate(controller='admin/comments'))

    def test_url_with_environ(self):

        m.minimization = True

        m.environ = dict(SCRIPT_NAME='/blog')

        m.connect(':controller/:action/:id')

    def test_url_with_environ_and_absolute(self):

        m.minimization = True

        m.environ = dict(SCRIPT_NAME='/blog')

        m.connect('image', 'image/:name', _absolute=True)

        eq_('/image/topnav.jpg', url_for('image', name='topnav.jpg'))

    def test_route_with_odd_leftovers(self):

        m.minimization = True

        m.connect(':controller/:(action)-:(id)')

        m.create_regs(['content','blog','admin/comments'])

        eq_('/content/index-', m.generate(controller='content'))

    def test_route_with_end_extension(self):

        m.connect(':controller/:(action)-:(id).html')

        m.create_regs(['content','blog','admin/comments'])

    return ['The matchdict items are %s and environ is %s' % (items, environ)]

def test_basic():

    map.minimization = True

    map.connect(':controller/:action/:id')

    map.create_regs(['content'])

    assert "matchdict items are [('action', 'index'), ('controller', u'content'), ('id', None)]" in res

def test_path_info():

    map.minimization = True

    map.connect('myapp/*path_info', controller='myapp')

    map.connect('project/*path_info', controller='myapp')

    assert "'PATH_INFO': '/pylonshq/browser/pylons/templates/default_project/+package+/pylonshq/browser/pylons/templates/default_project/+package+/controllers'" in res    

def test_redirect_middleware():

    map.minimization = True

    map.connect('myapp/*path_info', controller='myapp')

    map.redirect("faq/{section}", "/static/faq/{section}.html")

    eq_(res.headers['Location'], '/')

def test_method_conversion():

    map.minimization = True

    map.connect('content/:type', conditions=dict(method='DELETE'))

    map.connect(':controller/:action/:id')

def test_basic():

    m.minimization = False

    m.connect('/:controller/:action/:id')

    m.create_regs(['content'])

    eq_('/content/view/3', m.generate(controller='content', action='view', id=3))

def test_full():

    m.minimization = False

    m.connect('/:controller/:action/', id=None)

    m.connect('/:controller/:action/:id')

def test_action_required():

    m = Mapper()

    m.minimization = False

    m.connect('/:controller/index', action='index')

    m.create_regs(['content'])

def test_query_params():

    m = Mapper()

    m.minimization = False

    m.connect('/:controller/index', action='index')

    m.create_regs(['content'])

def test_syntax():

    m.minimization = False

    m.connect('/{controller}/{action}/{id}')

    m.create_regs(['content'])

    eq_('/content/view/3', m.generate(controller='content', action='view', id=3))

def test_regexp_syntax():

    m.minimization = False

    m.connect('/{controller}/{action}/{id:\d\d}')

    m.create_regs(['content'])

class TestRecognition(unittest.TestCase):

    def test_regexp_char_escaping(self):

        m.minimization = True

        m.connect(':controller/:(action).:(id)')

        m.create_regs(['content'])

        eq_(None, m.match('/findzall/view'))

    def test_all_static(self):

        m.minimization = True

        m.connect('hello/world/how/are/you', controller='content', action='index')

        m.create_regs([])

    def test_unicode(self):

        hoge = u'\u30c6\u30b9\u30c8' # the word test in Japanese

        hoge_enc = hoge.encode('utf-8')

        m.minimization = True

        m.connect(':hoge')

        eq_({'controller': 'content', 'action': 'index', 'hoge': hoge},

    def test_disabling_unicode(self):

        hoge = u'\u30c6\u30b9\u30c8' # the word test in Japanese

        hoge_enc = urllib.quote(hoge.encode('utf-8'))

        m.minimization = True

        m.encoding = None

        m.connect(':hoge')

    def test_basic_dynamic(self):

        for path in ['hi/:name', 'hi/:(name)']:

            m.minimization = True

            m.connect(path, controller='content')

            m.create_regs([])

    def test_basic_dynamic_backwards(self):

        for path in [':name/hi', ':(name)/hi']:

            m.minimization = True

            m.connect(path)

            m.create_regs([])

            eq_({'name':'index', 'action':'index', 'controller':'content'}, m.match('/index/hi'))

    def test_dynamic_with_underscores(self):

        m.minimization = True

        m.connect('article/:small_page', small_page=False)

        m.connect(':(controller)/:(action)/:(id)')

    def test_dynamic_with_default(self):

        for path in ['hi/:action', 'hi/:(action)']:

            m.minimization = True

            m.connect(path, controller='content')

            m.create_regs([])

    def test_dynamic_with_default_backwards(self):

        for path in [':action/hi', ':(action)/hi']:

            m.minimization = True

            m.connect(path, controller='content')

            m.create_regs([])

    def test_dynamic_with_string_condition(self):

        for path in [':name/hi', ':(name)/hi']:

            m.minimization = True

            m.connect(path, controller='content', requirements={'name':'index'})

            m.create_regs([])

    def test_dynamic_with_string_condition_backwards(self):

        for path in ['hi/:name', 'hi/:(name)']:

            m.minimization = True

            m.connect(path, controller='content', requirements={'name':'index'})

            m.create_regs([])

    def test_dynamic_with_regexp_condition(self):

        for path in ['hi/:name', 'hi/:(name)']:

            m.minimization = True

            m.connect(path, controller='content', requirements={'name':'[a-z]+'})

            m.create_regs([])

    def test_dynamic_with_regexp_and_default(self):

        for path in ['hi/:action', 'hi/:(action)']:

            m.minimization = True

            m.connect(path, controller='content', requirements={'action':'[a-z]+'})

            m.create_regs([])

    def test_dynamic_with_default_and_string_condition_backwards(self):

        for path in [':action/hi', ':(action)/hi']:

            m.minimization = True

            m.connect(path)

            m.create_regs([])

    def test_multiroute(self):

        m.minimization = True

        m.connect('archive/:year/:month/:day', controller='blog', action='view', month=None, day=None,

                                    requirements={'month':'\d{1,2}','day':'\d{1,2}'})

                         m.match('/archive/2004/10/23'))

    def test_multiroute_with_splits(self):

        m.minimization = True

        m.connect('archive/:(year)/:(month)/:(day)', controller='blog', action='view', month=None, day=None,

                                    requirements={'month':'\d{1,2}','day':'\d{1,2}'})

            eq_({'controller':'admin/user','action':'view','id':'4'}, m.match('/view/4/admin/user/super'))

    def test_dynamic_with_trailing_non_keyword_strings(self):

        m.minimization = True

        m.connect('somewhere/:over/rainbow', controller='blog')

        m.connect('somewhere/:over', controller='post')

        eq_({'controller':'admin/user', 'action':'hi'}, m.match('/hi/admin/user'))

    def test_standard_route(self):

        m.minimization = True

        m.connect(':controller/:action/:id')

        m.create_regs(['content','admin/user'])

        eq_({'controller':'content','action':'index'}, m.match('/'))

    def test_dynamic_with_prefix(self):

        m.minimization = True

        m.prefix = '/blog'

        m.connect(':controller/:action/:id')

        eq_({'controller':'archive','action':'view', 'id':'4'}, m.match('/blog/archive/view/4'))

    def test_dynamic_with_multiple_and_prefix(self):

        m.minimization = True

        m.prefix = '/blog'

        m.connect(':controller/:action/:id')

                         m.match('/group/view-5'))

    def test_splits_with_slashes_and_default(self):

        m.minimization = True

        m.connect(':name/:(action)-:(id)', controller='content')

        m.create_regs([])

        assert_raises(RoutesException, call_func)        

    def test_routematch(self):

        m.minimization = True

        m.connect(':controller/:action/:id')

        m.create_regs(['content'])

        eq_(None, m.routematch('/nowhere'))

    def test_routematch_debug(self):

        m.minimization = True

        m.connect(':controller/:action/:id')

        m.debug = True

        eq_(len(debug), 0)

    def test_match_debug(self):

        m.minimization = True

        m.connect('nowhere', 'http://nowhere.com/', _static=True)

        m.connect(':controller/:action/:id')

        eq_(len(debug), 0)

    def test_conditions(self):

        m.minimization = True

        m.connect('home/upload', controller='content', action='upload', conditions=dict(method=['POST']))

        m.connect(':controller/:action/:id')

        eq_({'action':'upload','controller':'content'}, con.mapper_dict)

    def test_subdomains(self):

        m.minimization = True

        m.sub_domains = True

        m.connect(':controller/:action/:id')

            con.mapper_dict)

    def test_subdomains_with_conditions(self):

        m.minimization = True

        m.sub_domains = True

        m.connect(':controller/:action/:id')

        eq_({'action': 'view', 'controller':'admin', 'sub_domain': 'fred'}, con.mapper_dict)

    def test_subdomains_with_ignore(self):

        m.minimization = True

        m.sub_domains = True

        m.sub_domains_ignore = ['www']

            con.mapper_dict)

    def test_other_special_chars(self):

        m.minimization = True

        m.connect('/:year/:(slug).:(format),:(locale)', format='html', locale='en')

        m.connect('/error/:action/:id', controller='error')

                          'id': 'icon-16.png'}, m.match('/error/img/icon-16.png'))

    def test_various_periods(self):

        m.minimization = True

        m.connect('sites/:site/pages/:page')

        m.create_regs(['content'])

        eq_({'action': u'index', 'controller': u'content', 

                          'site': u'python.com', 'page': u'index.html'}, 

                         m.match('/sites/python.com/pages/index.html'))

        m.minimization = True

        m.connect('sites/:site/pages/:page.:format', format='html')

        m.create_regs(['content'])

                         m.match('/sites/python.com/pages/index.html'))

    def test_empty_fails(self):

        m.minimization = True

        m.connect(':controller/:action/:id')

        m.connect('', controller='content', action='view', id=4)

        assert_raises(RoutesException, call_func)

    def test_home_noargs(self):

        m.minimization = True

        m.connect('')

        m.create_regs([])

        assert_raises(Exception, url_for, 'entry', id='foo')

    def test_submapper_action(self):

        c = m.submapper(path_prefix='/entries', controller='entry')

        c.action(name='entries', action='list')

        assert_raises(Exception, url_for, 'entries', method='DELETE')

    def test_submapper_link(self):

        c = m.submapper(path_prefix='/entries', controller='entry')

        c.link(rel='new')

class TestUtils(unittest.TestCase):

    def setUp(self):

        m.minimization = True

        m.connect('archive/:year/:month/:day', controller='blog', action='view', month=None, day=None,

                  requirements={'month':'\d{1,2}','day':'\d{1,2}'})

        self.con.mapper_dict = {}

        self.con.environ = dict(SCRIPT_NAME='', HTTP_HOST='example.com')

        m.minimization = True

        m.connect(':controller/:(action)-:(id).html')

        m.connect('archives', 'archives/:year/:month/:day/:slug', controller='archives', action='view',

        self.con.mapper_dict = {}

        self.con.environ = base_environ.copy()

        m.minimization = True

        m.connect(':controller/:action/:id')

        m.create_regs(['content','archives','admin/comments'])

        self.con.environ = base_environ.copy()

        self.con.mapper_dict = {}

        m.minimization = True

        m.connect(':controller/:action/:id')

        m.create_regs(['content','archives','admin/comments'])

        self.con.mapper_dict = {}

        self.con.environ = base_environ.copy()

        m.minimization = True

        m.sub_domains = True

        m.connect(':controller/:action/:id')

        self.con.mapper_dict = {}

        self.con.environ = base_environ.copy()

        m.minimization = True

        m.sub_domains = True

        m.sub_domains_ignore = ['www']

        self.con.mapper_dict = {}

        self.con.environ = base_environ.copy()

        m.minimization = True

        m.sub_domains = True

        m.connect(':controller/:action/:id')

        self.con.mapper_dict = {}

        self.con.environ = base_environ.copy()

        m.minimization = True

        m.sub_domains = True

        m.connect(':controller/:action/:id')

        here_dir = os.path.dirname(__file__)

        controller_dir = os.path.join(os.path.dirname(here_dir), 

            os.path.join('test_files', 'controller_files'))

        m.minimization = True

        m.always_scan = True

        m.connect(':controller/:action/:id')

class TestUtilsWithExplicit(unittest.TestCase):

    def setUp(self):

        m.minimization = True

        m.connect('archive/:year/:month/:day', controller='blog', action='view', month=None, day=None,

                  requirements={'month':'\d{1,2}','day':'\d{1,2}'})

    unittest.main()

else:

    def bench_gen(withcache = False):

        m.connect('', controller='articles', action='index')

        m.connect('admin', controller='admin/general', action='index')

class TestEnvironment(unittest.TestCase):

    def setUp(self):

        m.minimization = True

        m.connect('archive/:year/:month/:day', controller='blog', action='view', month=None, day=None,

                  requirements={'month':'\d{1,2}','day':'\d{1,2}'})