def generate_non_minimized(self, kargs):
        """Generate a non-minimal version of the URL"""
        # Iterate through the keys that are defaults, and NOT in the route
        # path. If its not in kargs, or doesn't match, or is None, this
        # route won't work
        for k in self.maxkeys - self.minkeys:
            if k not in kargs:
                return False
            elif self.make_unicode(kargs[k]) != \
                self.make_unicode(self.defaults[k]):
                return False

        # Ensure that all the args in the route path are present and not None
        for arg in self.minkeys:
            if arg not in kargs or kargs[arg] is None:
                if arg in self.dotkeys:
                    kargs[arg] = ''
                else:
                    return False

        # Encode all the argument that the regpath can use
        for k in kargs:
            if k in self.maxkeys:
                if k in self.dotkeys:
                    if kargs[k]:
                        kargs[k] = url_quote(
                            '.' + as_unicode(kargs[k], self.encoding),
                            self.encoding)
                else:
                    kargs[k] = url_quote(as_unicode(kargs[k], self.encoding),
                                         self.encoding)

        return self.regpath % kargs
Exemple #2
0
    def generate_non_minimized(self, kargs):
        """Generate a non-minimal version of the URL"""
        # Iterate through the keys that are defaults, and NOT in the route
        # path. If its not in kargs, or doesn't match, or is None, this
        # route won't work
        for k in self.maxkeys - self.minkeys:
            if k not in kargs:
                return False
            elif self.make_unicode(kargs[k]) != self.make_unicode(self.defaults[k]):
                return False

        # Ensure that all the args in the route path are present and not None
        for arg in self.minkeys:
            if arg not in kargs or kargs[arg] is None:
                if arg in self.dotkeys:
                    kargs[arg] = ""
                else:
                    return False

        # Encode all the argument that the regpath can use
        for k in kargs:
            if k in self.maxkeys:
                if k in self.dotkeys:
                    if kargs[k]:
                        kargs[k] = url_quote("." + kargs[k], self.encoding)
                else:
                    kargs[k] = url_quote(kargs[k], self.encoding)

        return self.regpath % kargs
 def generate_minimized(self, kargs):
     """Generate a minimized version of the URL"""
     routelist = self.routebackwards
     urllist = []
     gaps = False
     for part in routelist:
         if isinstance(part, dict) and part['type'] == ':':
             arg = part['name']
             
             # For efficiency, check these just once
             has_arg = kargs.has_key(arg)
             has_default = self.defaults.has_key(arg)
             
             # Determine if we can leave this part off
             # First check if the default exists and wasn't provided in the 
             # call (also no gaps)
             if has_default and not has_arg and not gaps:
                 continue
                 
             # Now check to see if there's a default and it matches the 
             # incoming call arg
             if (has_default and has_arg) and self.make_unicode(kargs[arg]) == \
                 self.make_unicode(self.defaults[arg]) and not gaps: 
                 continue
             
             # We need to pull the value to append, if the arg is None and 
             # we have a default, use that
             if has_arg and kargs[arg] is None and has_default and not gaps:
                 continue
             
             # Otherwise if we do have an arg, use that
             elif has_arg:
                 val = kargs[arg]
             
             elif has_default and self.defaults[arg] is not None:
                 val = self.defaults[arg]
             
             # No arg at all? This won't work
             else:
                 return False
             
             urllist.append(url_quote(val, self.encoding))
             if has_arg:
                 del kargs[arg]
             gaps = True
         elif isinstance(part, dict) and part['type'] == '*':
             arg = part['name']
             kar = kargs.get(arg)
             if kar is not None:
                 urllist.append(url_quote(kar, self.encoding))
                 gaps = True
         elif part and part[-1] in self.done_chars:
             if not gaps and part in self.done_chars:
                 continue
             elif not gaps:
                 urllist.append(part[:-1])
                 gaps = True
             else:
                 gaps = True
                 urllist.append(part)
         else:
             gaps = True
             urllist.append(part)
     urllist.reverse()
     url = ''.join(urllist)
     return url
    def generate_minimized(self, kargs):
        """Generate a minimized version of the URL"""
        routelist = self.routebackwards
        urllist = []
        gaps = False
        for part in routelist:
            if isinstance(part, dict) and part['type'] in (':', '.'):
                arg = part['name']

                # For efficiency, check these just once
                has_arg = kargs.has_key(arg)
                has_default = self.defaults.has_key(arg)

                # Determine if we can leave this part off
                # First check if the default exists and wasn't provided in the
                # call (also no gaps)
                if has_default and not has_arg and not gaps:
                    continue

                # Now check to see if there's a default and it matches the
                # incoming call arg
                if (has_default and has_arg) and self.make_unicode(kargs[arg]) == \
                    self.make_unicode(self.defaults[arg]) and not gaps:
                    continue

                # We need to pull the value to append, if the arg is None and
                # we have a default, use that
                if has_arg and kargs[arg] is None and has_default and not gaps:
                    continue

                # Otherwise if we do have an arg, use that
                elif has_arg:
                    val = kargs[arg]

                elif has_default and self.defaults[arg] is not None:
                    val = self.defaults[arg]
                # Optional format parameter?
                elif part['type'] == '.':
                    continue
                # No arg at all? This won't work
                else:
                    return False

                val = as_unicode(val, self.encoding)
                urllist.append(url_quote(val, self.encoding))
                if part['type'] == '.':
                    urllist.append('.')

                if has_arg:
                    del kargs[arg]
                gaps = True
            elif isinstance(part, dict) and part['type'] == '*':
                arg = part['name']
                kar = kargs.get(arg)
                if kar is not None:
                    urllist.append(url_quote(kar, self.encoding))
                    gaps = True
            elif part and part[-1] in self.done_chars:
                if not gaps and part in self.done_chars:
                    continue
                elif not gaps:
                    urllist.append(part[:-1])
                    gaps = True
                else:
                    gaps = True
                    urllist.append(part)
            else:
                gaps = True
                urllist.append(part)
        urllist.reverse()
        url = ''.join(urllist)
        return url