/root/Elgg/engine/lib/output.php

Converts shorthand urls to absolute urls.No change is made if the URL: is absolute, protocol-relative, starts with a protocol/fragment/query.

elgg_normalize_url(''); // 'http://my.site.com/' elgg_normalize_url('dashboard'); // 'http://my.site.com/dashboard' elgg_normalize_url('http://google.com/'); // no change elgg_normalize_url('//google.com/'); // no change

Parameters

string

$url

The URL to normalize

Returns

string The absolute url

<?php
function parse_urls($text) {
 
    $linkify = new \Misd\Linkify\Linkify();
        
    return $linkify->processUrls($text, ['attr' => ['rel' => 'nofollow']]);
}
 
function elgg_parse_emails($text) {
    $linkify = new \Misd\Linkify\Linkify();
        
    return $linkify->processEmails($text, ['attr' => ['rel' => 'nofollow']]);
}
 
function elgg_autop($string) {
    return _elgg_services()->autoP->process($string);
}
 
function elgg_get_excerpt($text, $num_chars = 250) {
    $view = 'output/excerpt';
    $vars = [
        'text' => $text,
        'num_chars' => $num_chars,
    ];
    $viewtype = elgg_view_exists($view) ? '' : 'default';
 
    return _elgg_view_under_viewtype($view, $vars, $viewtype);
}
 
function elgg_format_url($url) {
    return preg_replace('/&(?!amp;)/', '&amp;', $url);
}
 
function elgg_format_bytes($size, $precision = 2) {
    if (!$size || $size < 0) {
        return false;
    }
 
    $base = log($size) / log(1024);
    $suffixes = array('B', 'kB', 'MB', 'GB', 'TB');
 
    return round(pow(1024, $base - floor($base)), $precision) . ' ' . $suffixes[floor($base)];
}
 
function elgg_format_attributes(array $attrs = array()) {
    if (!is_array($attrs) || empty($attrs)) {
        return '';
    }
 
    $attributes = [];
 
    foreach ($attrs as $attr => $val) {
        if (0 !== strpos($attr, 'data-') && false !== strpos($attr, '_')) {
            // this is probably a view $vars variable not meant for output
            continue;
        }
 
        $attr = strtolower($attr);
 
        if (!isset($val) || $val === false) {
            continue;
        }
 
        if ($val === true) {
            $val = $attr; //e.g. checked => true ==> checked="checked"
        }
 
        if (is_scalar($val)) {
            $val = [$val];
        }
 
        if (!is_array($val)) {
            continue;
        }
 
        // Check if array contains non-scalar values and bail if so
        $filtered_val = array_filter($val, function($e) {
            return is_scalar($e);
        });
 
        if (count($val) != count($filtered_val)) {
            continue;
        }
 
        $val = implode(' ', $val);
 
        $val = htmlspecialchars($val, ENT_QUOTES, 'UTF-8', false);
        $attributes[] = "$attr=\"$val\"";
    }
 
    return implode(' ', $attributes);
}
 
function elgg_format_element($tag_name, array $attributes = array(), $text = '', array $options = array()) {
    if (is_array($tag_name)) {
        $args = $tag_name;
 
        if ($attributes !== [] || $text !== '' || $options !== []) {
            throw new \InvalidArgumentException('If $tag_name is an array, the other arguments must not be set');
        }
 
        if (isset($args['#tag_name'])) {
            $tag_name = $args['#tag_name'];
        }
        if (isset($args['#text'])) {
            $text = $args['#text'];
        }
        if (isset($args['#options'])) {
            $options = $args['#options'];
        }
 
        unset($args['#tag_name'], $args['#text'], $args['#options']);
        $attributes = $args;
    }
 
    if (!is_string($tag_name) || $tag_name === '') {
        throw new \InvalidArgumentException('$tag_name is required');
    }
 
    if (isset($options['is_void'])) {
        $is_void = $options['is_void'];
    } else {
        // from http://www.w3.org/TR/html-markup/syntax.html#syntax-elements
        $is_void = in_array(strtolower($tag_name), array(
            'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'menuitem',
            'meta', 'param', 'source', 'track', 'wbr'
        ));
    }
 
    if (!empty($options['encode_text'])) {
        $double_encode = empty($options['double_encode']) ? false : true;
        $text = htmlspecialchars($text, ENT_QUOTES, 'UTF-8', $double_encode);
    }
 
    if ($attributes) {
        $attrs = elgg_format_attributes($attributes);
        if ($attrs !== '') {
            $attrs = " $attrs";
        }
    } else {
        $attrs = '';
    }
 
    if ($is_void) {
        return empty($options['is_xml']) ? "<{$tag_name}{$attrs}>" : "<{$tag_name}{$attrs} />";
    } else {
        return "<{$tag_name}{$attrs}>$text</$tag_name>";
    }
}
 
function elgg_normalize_url($url) {
    $url = str_replace(' ', '%20', $url);
 
    if (_elgg_sane_validate_url($url)) {
        return $url;
    }
 
    if (preg_match("#^([a-z]+)\\:#", $url, $m)) {
        // we don't let http/https: URLs fail filter_var(), but anything else starting with a protocol
        // is OK
        if ($m[1] !== 'http' && $m[1] !== 'https') {
            return $url;
        }
    }
 
    if (preg_match("#^(\\#|\\?|//)#", $url)) {
        // starts with '//' (protocol-relative link), query, or fragment
        return $url;
    }
 
    if (preg_match("#^[^/]*\\.php(\\?.*)?$#", $url)) {
        // root PHP scripts: 'install.php', 'install.php?step=step'. We don't want to confuse these
        // for domain names.
        return elgg_get_site_url() . $url;
    }
 
    if (preg_match("#^[^/?]*\\.#", $url)) {
        // URLs starting with domain: 'example.com', 'example.com/subpage'
        return "http://$url";
    }
 
    // 'page/handler', 'mod/plugin/file.php'
    // trim off any leading / because the site URL is stored
    // with a trailing /
    return elgg_get_site_url() . ltrim($url, '/');
}
 
function elgg_normalize_site_url($unsafe_url) {
    if (!is_string($unsafe_url)) {
        return false;
    }
 
    $unsafe_url = elgg_normalize_url($unsafe_url);
    if (0 === strpos($unsafe_url, elgg_get_site_url())) {
        return $unsafe_url;
    }
 
    return false;
}
 
function elgg_get_friendly_title($title) {
 
    // return a URL friendly title to short circuit normal title formatting
    $params = array('title' => $title);
    $result = elgg_trigger_plugin_hook('format', 'friendly:title', $params, null);
    if ($result) {
        return $result;
    }
 
    // titles are often stored HTML encoded
    $title = html_entity_decode($title, ENT_QUOTES, 'UTF-8');
    
    $title = \Elgg\Translit::urlize($title);
 
    return $title;
}
 
function elgg_get_friendly_time($time, $current_time = null) {
    
    if (!$current_time) {
        $current_time = time();
    }
 
    // return a time string to short circuit normal time formatting
    $params = array('time' => $time, 'current_time' => $current_time);
    $result = elgg_trigger_plugin_hook('format', 'friendly:time', $params, null);
    if ($result) {
        return $result;
    }
 
    $diff = abs((int)$current_time - (int)$time);
 
    $minute = 60;
    $hour = $minute * 60;
    $day = $hour * 24;
 
    if ($diff < $minute) {
        return elgg_echo("friendlytime:justnow");
    }
    
    if ($diff < $hour) {
        $granularity = ':minutes';
        $diff = round($diff / $minute);
    } else if ($diff < $day) {
        $granularity = ':hours';
        $diff = round($diff / $hour);
    } else {
        $granularity = ':days';
        $diff = round($diff / $day);
    }
 
    if ($diff == 0) {
        $diff = 1;
    }
    
    $future = ((int)$current_time - (int)$time < 0) ? ':future' : '';
    $singular = ($diff == 1) ? ':singular' : '';
 
    return elgg_echo("friendlytime{$future}{$granularity}{$singular}", array($diff));
}
 
function elgg_get_friendly_upload_error($error_code) {
    switch ($error_code) {
        case UPLOAD_ERR_OK:
            return '';
            
        case UPLOAD_ERR_INI_SIZE:
            $key = 'ini_size';
            break;
        
        case UPLOAD_ERR_FORM_SIZE:
            $key = 'form_size';
            break;
 
        case UPLOAD_ERR_PARTIAL:
            $key = 'partial';
            break;
 
        case UPLOAD_ERR_NO_FILE:
            $key = 'no_file';
            break;
 
        case UPLOAD_ERR_NO_TMP_DIR:
            $key = 'no_tmp_dir';
            break;
 
        case UPLOAD_ERR_CANT_WRITE:
            $key = 'cant_write';
            break;
 
        case UPLOAD_ERR_EXTENSION:
            $key = 'extension';
            break;
        
        default:
            $key = 'unknown';
            break;
    }
 
    return elgg_echo("upload:error:$key");
}
 
 
function elgg_strip_tags($string, $allowable_tags = null) {
    $params['original_string'] = $string;
    $params['allowable_tags'] = $allowable_tags;
 
    $string = strip_tags($string, $allowable_tags);
    $string = elgg_trigger_plugin_hook('format', 'strip_tags', $params, $string);
 
    return $string;
}
 
function elgg_html_decode($string) {
    $string = str_replace(
        array('&gt;', '&lt;', '&amp;', '&quot;', '&#039;'),
        array('&amp;gt;', '&amp;lt;', '&amp;amp;', '&amp;quot;', '&amp;#039;'),
        $string
    );
    $string = html_entity_decode($string, ENT_NOQUOTES, 'UTF-8');
    $string = str_replace(
        array('&amp;gt;', '&amp;lt;', '&amp;amp;', '&amp;quot;', '&amp;#039;'),
        array('&gt;', '&lt;', '&amp;', '&quot;', '&#039;'),
        $string
    );
    return $string;
}
 
function _elgg_html_decode($string) {
    elgg_deprecated_notice(__FUNCTION__ . ' is deprecated. Use elgg_html_decode()', '2.0');
    return elgg_html_decode($string);
}
 
function _elgg_get_display_query($string) {
    //encode <,>,&, quotes and characters above 127
    if (function_exists('mb_convert_encoding')) {
        $display_query = mb_convert_encoding($string, 'HTML-ENTITIES', 'UTF-8');
    } else {
        // if no mbstring extension, we just strip characters
        $display_query = preg_replace("/[^\x01-\x7F]/", "", $string);
    }
    return htmlspecialchars($display_query, ENT_QUOTES, 'UTF-8', false);
}
 
function _elgg_sane_validate_url($url) {
    // based on http://php.net/manual/en/function.filter-var.php#104160
    $res = filter_var($url, FILTER_VALIDATE_URL);
    if ($res) {
        return $res;
    }
 
    // Check if it has unicode chars.
    $l = elgg_strlen($url);
    if (strlen($url) == $l) {
        return $res;
    }
 
    // Replace wide chars by “X”.
    $s = '';
    for ($i = 0; $i < $l; ++$i) {
        $ch = elgg_substr($url, $i, 1);
        $s .= (strlen($ch) > 1) ? 'X' : $ch;
    }
 
    // Re-check now.
    return filter_var($s, FILTER_VALIDATE_URL) ? $url : false;
}
 
return function(\Elgg\EventsService $events, \Elgg\HooksRegistrationService $hooks) {
 
};