If there is a current override, resolve it to an absolute url based on current request.
554806
private function resolveCurrentOverride()
    {
        // Absolute url or network path
        if ($this->override->getHost() !== '') {
            return;
        }

        $context = $this->urlGenerator->getContext();

        if (Uri::isRelativePathReference($this->override)) {
            $this->override = $this->override->withPath($context->getPathInfo() . '/' . $this->override->getPath());
        }

        $scheme = $this->forceSsl ? 'https' : $context->getScheme();
        $this->override = $this->override
            ->withScheme($scheme)
            ->withHost($context->getHost())
            ->withPort($scheme === 'http' ? $context->getHttpPort() : $context->getHttpsPort())
            ->withPath($context->getBaseUrl() . $this->override->getPath())
        ;
    }
972352
def absolute_url
      assert_exists
      href = @object.getAttribute('href')

      unless href.empty? || URI.parse(href).absolute?
        href = URI.join(browser.url, href).to_s
      end

      href
    end
819769
function resolveUrl(url){
    
    // replace all // except the one in proto with /
    url = url.replace(reDoubleSlash, "$1/");
    
    // If the url is a valid url we do nothing
    if (!url.match(/^(http||https):\/\//)) {
        // If this is a relative path
        var path = (url.substring(0, 1) === "/") ? "" : location.pathname;
        if (path.substring(path.length - 1) !== "/") {
            path = path.substring(0, path.lastIndexOf("/") + 1);
        }
        
        url = location.protocol + "//" + location.host + path + url;
    }
    
    // reduce all 'xyz/../' to just '' 
    while (reParent.test(url)) {
        url = url.replace(reParent, "");
    }
    
    return url;
}
452611
def _get_url(self, url):
        """"""
        if self.base_url and not url.startswith(('http://', 'https://')):
            return urljoin(self.base_url, url)
        return url
56487
def get(self, request, *args, **kwargs):
        
        entry = self.get_object()
        return HttpResponsePermanentRedirect(entry.get_absolute_url())
682891
function absoluteUrl (baseUrl, pathUrl) {
  if (pathUrl && pathUrl.slice(0, 4) !== 'http') {
    return [baseUrl, pathUrl].map((path) => {
      if (path[0] === '/') {
        path = path.slice(1)
      }
      if (path[path.length - 1] === '/') {
        path = path.slice(0, path.length - 1)
      }
      return path
    }).join('/')
  }

  return pathUrl
}
103998
def base_url(root):
    """"""
    for attr, value in root.attrib.iteritems():
        if attr.endswith('base') and 'http' in value:
            return value
    return None
603185
def get_absolute_url(self):
        """"""

        # Determine if this configuration is on a stage
        if self.stage:
            # Stage specific configurations go back to the stage view
            url = reverse('projects_stage_view', args=(self.project.pk, self.stage.pk))
        else:
            # Project specific configurations go back to the project page
            url = self.project.get_absolute_url()

        return url
818360
public static function resolve()
    {
        // Get current URL
        $oRequest = new Request();
        $sUrl = $oRequest->url();
        // Set default separator
        if (Configuration::check('routing.default_separator') === true) {
            $cDefaultSeparator = Configuration::read('routing.default_separator');
            RouteCollection::setDefaultSeparator($cDefaultSeparator);
        }
        // Remove last char of URL if it's a separator
        $sUrl = self::removeLastSeparator($sUrl);
        // Get list of separator for this URL
        $arcUrlSeparator = self::listSeparator($sUrl);
        // Get list of value of this URL
        $arsUrlValue = self::listValue($sUrl);
        // Check route
        $bCheckResult = self::checkRoute($arcUrlSeparator, $arsUrlValue);
        if ($bCheckResult === false && Configuration::read('routing.auto') === true) {
            self::autoResolve($arsUrlValue);
        }
        self::checkController();
        self::setParameterInGlobal();
    }
934143
function absoluteURI(uri, base) {
    if (uri.substr(0, 2) == './')
      uri = uri.substr(2);

    // absolute urls are left in tact
    if (uri.match(absUrlRegEx) || uri.match(protocolRegEx))
      return uri;
    
    var baseParts = base.split('/');
    var uriParts = uri.split('/');
    
    baseParts.pop();
    
    while (curPart = uriParts.shift())
      if (curPart == '..')
        baseParts.pop();
      else
        baseParts.push(curPart);
    
    return baseParts.join('/');
  }
566753
def static_absolute_tag(context, path):
    
    request = context.get("request")
    return urljoin(request.ABSOLUTE_ROOT, static_url(path))
1106624
def checkURL(cls, trust_root, url):
        """"""
        tr = cls.parse(trust_root)
        return tr is not None and tr.validateURL(url)
366592
function resolveURL(url) {
		return new URI(url).absoluteTo(new URI(document.baseURI).search("")).toString();
	}
603888
def get_obj_url(request, obj):
    
    if (is_callable(getattr(obj, 'get_absolute_url', None)) and
            (not hasattr(obj, 'can_see_edit_link') or
             (is_callable(getattr(obj, 'can_see_edit_link', None)) and obj.can_see_edit_link(request)))):
        return call_method_with_unknown_input(obj.get_absolute_url, request=request)
    else:
        return get_url_from_model_core(request, obj)
724717
def build_absolute_uri(self, uri):
        
        request = self.context.get('request', None)

        return (
            request.build_absolute_uri(uri) if request is not None else uri
        )
318339
def get_absolute_url_link(self, text=None, cls=None, icon_class=None,
                              **attrs):
        """"""
        if text is None:
            text = self.get_link_text()

        return build_link(href=self.get_absolute_url(),
                          text=text,
                          cls=cls,
                          icon_class=icon_class,
                          **attrs)
400009
def if_url(context, url_name, yes, no):
    
    current = context["request"].resolver_match.url_name
    return yes if url_name == current else no