The full url rule for this route, including any blueprint prefix.
166898
def full_rule(self):
        
        return join(self.bp_prefix, self.rule, trailing_slash=self.rule.endswith('/'))
877654
public String getFullPath() {

        String path = m_resource.getRootPath();
        if ((m_siteMode != SITE_MODE_ROOT) && (m_cms != null)) {
            String site = getSite();
            if (path.startsWith(site)) {
                path = path.substring(site.length());
            }
        }
        return path;
    }
713673
def search_rule(self, search):
        
        return [RouteMapRule(**rule) for rule in self.make_request( 
            resource='search_rule', params={'filter': search})]
621953
public static function fullUrl($addSufFix = true, $joinParams = true)
    {
        $params = '';
        if ($joinParams) {
            $get = $_GET;
            unset($get[Config::get('var_pathinfo')]);
            $params = http_build_query($get);
            $params && $params = '?' . $params;
        }
        return Request::baseUrl() . '/' . implode('/', Route::getPathInfo()) . ($addSufFix ? Config::get('url_html_suffix') : '') . $params;
    }
47087
public function buildComplete($url = null, $full = false) {
		if (is_array($url)) {
			$url = $this->addQueryStrings($url);
		}

		return Router::url($url, $full);
	}
739836
def make_full_qualified_url(self, path: str) -> str:
        
        return self.application_uri.rstrip('/') + '/' + path.lstrip('/')
638670
def permalink
      templatable_page = Kms::Page.where(templatable_type: self.class.name).first
      if templatable_page
        Pathname.new(templatable_page.parent.fullpath).join(slug.to_s).to_s
      end
    end
883647
public String path() {
    /* build the fully qualified url with all query parameters */
    StringBuilder path = new StringBuilder();
    if (this.target != null) {
      path.append(this.target);
    }
    if (this.uriTemplate != null) {
      path.append(this.uriTemplate.toString());
    }
    if (path.length() == 0) {
      /* no path indicates the root uri */
      path.append("/");
    }
    return path.toString();

  }
952745
def full_url(self):
        """"""
        if self.needs_auth:
            netloc = '%s:%s@%s' % (self.username, self.password, self.netloc)
        else:
            netloc = self.netloc
        return urlunparse((
            self.scheme,
            netloc,
            self.path,
            self.params,
            self.query,
            self.fragment,
        ))
623790
def set_urlroute_rules(rules=None):
    
    global __url_route_rules__
    __url_route_rules__ = []
    for k, v in (rules or {}).values():
        __url_route_rules__.append((re.compile(k), v))
804597
public function getFullUrl()
    {
        /** @var Uri $uri */
        $uri = $this->getUri();

        return rtrim($uri->getBaseUrl(), '/') . '/' . ltrim($uri->getPath(), '/');
    }
829128
def content_for route
      parts = route.split("/").delete_if &:empty?
      content = parts.inject(self) do |page, part|
        page.children[part.to_sym] if page
      end
      content
    end
834455
public String makeFullPath(String prefix, String... name) {
        StringBuilder sb=new StringBuilder(prefix == null ? "/" : (prefix.equals("/")?prefix:prefix+"/"));
        boolean first=true;
        for (String s : name) {
            if(s==null) continue;
            if(!first){
                sb.append("/");
            }else
                first=false;
            sb.append(s);
        }
        return sb.toString();
    }
466135
def flattened_params_url(self, path_prefix, *paths, **kparams):
        

        base = self.base_url + path_prefix
        for p in paths:
            base += "/"
            base += p
        if kparams:
            base += "?"
            # use %r in val?
            base += '&'.join("%s=%s" % (key,val) for (key,val) in kparams.items())
        return base
1250582
def path(self):
        ""
        prefix = ()
        if self.parent:
            prefix = self.parent.path

        if self.id_or_name:
            return prefix + (self.kind, self.id_or_name)

        return prefix + (self.kind,)
209647
def _build_urlmapping(urls, strict_slashes=False, **kwargs):
    

    rules = _build_rules(urls)
    return Map(rules=list(rules), strict_slashes=strict_slashes, **kwargs)
135849
def include_route?(route)
      value = false

      unless route.blank? || route.path.spec =~ %r{/rails/info/properties|^/assets}
        # this block looks very busy, but, actually all that is really going on here is we are matching
        # parts of the current route against sitemap_filter data configured via config/routes.rb, then,
        # raising and catching exceptions based on the outcome of each evaluation.
        # the rule is all routes excluded, unless included via some type of filter criteria.

        begin

          DuckMap.logger.debug "\r\n  Route: #{route.verb_symbol} #{route.route_name.ljust(30)} #{route.controller_name} => #{route.action_name}"
          DuckMap.logger.debug route
          DuckMap.logger.debug %(#{"Path:".rjust(30)} #{route.path.spec})

          # we don't want to include routes without a name.
          if route.name.blank?
            unless self.blank_route_name?
              raise RouteNameMissing, "route name blank"
            end
          end

          if match_any?(route.action_name, route.exclude_actions) ||
              match_any?(route.controller_name, route.exclude_controllers) ||
              match_any?(route.name, route.exclude_names) ||
              match_any?(route.verb_symbol, route.exclude_verbs)

            raise DuckmapExclude, "exclude"

          end

          if match_any?(route.action_name, route.include_actions) ||
              match_any?(route.controller_name, route.include_controllers) ||
              match_any?(route.name, route.include_names) ||
              match_any?(route.verb_symbol, route.include_verbs)

            raise DuckmapInclude, "include"

          end

          if match_any?(route.action_name, self.sitemap_filters.current_filter[:exclude][:actions])
            raise ExplicitExclude, "exclude"
          end

          if match_any?(route.verb_symbol, self.sitemap_filters.current_filter[:exclude][:verbs])
            raise ExplicitExclude, "exclude"
          end

          if match_any?(route.controller_name, self.sitemap_filters.current_filter[:exclude][:controllers])
            raise ExplicitExclude, "exclude"
          end

          if match_any?(route.name, self.sitemap_filters.current_filter[:exclude][:names])
            raise ExplicitExclude, "exclude"
          end

          if match_any?(route.action_name, self.sitemap_filters.current_filter[:include][:actions])
            raise ExplicitInclude, "include"
          end

          if match_any?(route.verb_symbol, self.sitemap_filters.current_filter[:include][:verbs])
            raise ExplicitInclude, "include"
          end

          if match_any?(route.controller_name, self.sitemap_filters.current_filter[:include][:controllers])
            raise ExplicitInclude, "include"
          end

          if match_any?(route.name, self.sitemap_filters.current_filter[:include][:names])
            raise ExplicitInclude, "include"
          end

        rescue DuckmapExclude => e
          DuckMap.logger.debug %(#{"Duckmap Exclude".rjust(30)} -> #{e})

          if match_any?(route.action_name, route.include_actions) ||
              match_any?(route.controller_name, route.include_controllers) ||
              match_any?(route.name, route.include_names) ||
              match_any?(route.verb_symbol, route.include_verbs)

            DuckMap.logger.debug %(#{"Duckmap Exclude".rjust(30)} -> included again...)
            value = true
          end

        rescue DuckmapInclude => e
          DuckMap.logger.debug %(#{"Duckmap Include".rjust(30)} -> #{e})
          value = true

        rescue ExplicitExclude => e
          DuckMap.logger.debug %(#{"Explicit Exclude".rjust(30)} -> #{e})

        rescue ExplicitInclude => e
          DuckMap.logger.debug %(#{"Explicit Include".rjust(30)} -> #{e})
          value = true

        rescue RouteNameMissing => e
          DuckMap.logger.debug %(#{"Route Name Missing".rjust(30)} -> #{e})

        rescue Exception => e
          DuckMap.logger.info %(#{"Unknown Exception".rjust(30)} -> #{e})
          DuckMap.logger.info e.backtrace.join("\r\n")
        end

      end

      return value
    end