3 +--------------------------------------------------------------------+
4 | CiviCRM version 4.7 |
5 +--------------------------------------------------------------------+
6 | Copyright CiviCRM LLC (c) 2004-2015 |
7 +--------------------------------------------------------------------+
8 | This file is a part of CiviCRM. |
10 | CiviCRM is free software; you can copy, modify, and distribute it |
11 | under the terms of the GNU Affero General Public License |
12 | Version 3, 19 November 2007 and the CiviCRM Licensing Exception. |
14 | CiviCRM is distributed in the hope that it will be useful, but |
15 | WITHOUT ANY WARRANTY; without even the implied warranty of |
16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
17 | See the GNU Affero General Public License for more details. |
19 | You should have received a copy of the GNU Affero General Public |
20 | License and the CiviCRM Licensing Exception along |
21 | with this program; if not, contact CiviCRM LLC |
22 | at info[AT]civicrm[DOT]org. If you have questions about the |
23 | GNU Affero General Public License or the licensing of CiviCRM, |
24 | see the CiviCRM license FAQ at http://civicrm.org/licensing |
25 +--------------------------------------------------------------------+
31 * @copyright CiviCRM LLC (c) 2004-2015
35 require_once 'HTML/QuickForm/Rule/Email.php';
38 * This class contains string functions.
41 class CRM_Utils_String
{
42 const COMMA
= ",", SEMICOLON
= ";", SPACE
= " ", TAB
= "\t", LINEFEED
= "\n", CARRIAGELINE
= "\r\n", LINECARRIAGE
= "\n\r", CARRIAGERETURN
= "\r";
45 * List of all letters and numbers
47 const ALPHANUMERIC
= 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890';
50 * Convert a display name into a potential variable name.
52 * @param $title title of the string
53 * @param int $maxLength
56 * An equivalent variable name.
58 public static function titleToVar($title, $maxLength = 31) {
59 $variable = self
::munge($title, '_', $maxLength);
61 if (CRM_Utils_Rule
::title($variable, $maxLength)) {
65 // if longer than the maxLength lets just return a substr of the
66 // md5 to prevent errors downstream
67 return substr(md5($title), 0, $maxLength);
71 * Replace all non alpha numeric characters and spaces with the replacement character.
74 * The name to be worked on.
76 * The character to use for non-valid chars.
78 * Length of valid variables.
81 * returns the manipulated string
83 public static function munge($name, $char = '_', $len = 63) {
84 // Replace all white space and non-alpha numeric with $char
85 // we only use the ascii character set since mysql does not create table names / field names otherwise
87 $name = preg_replace('/[^a-zA-Z0-9]+/', $char, trim($name));
90 // lets keep variable names short
91 return substr($name, 0, $len);
99 * Convert possibly underscore separated words to camel case with special handling for 'UF'
100 * e.g membership_payment returns MembershipPayment
102 * @param string $string
106 public static function convertStringToCamel($string) {
113 if (isset($map[$string])) {
114 return $map[$string];
117 $fragments = explode('_', $string);
118 foreach ($fragments as & $fragment) {
119 $fragment = ucfirst($fragment);
121 // Special case: UFGroup, UFJoin, UFMatch, UFField
122 if ($fragments[0] === 'Uf') {
123 $fragments[0] = 'UF';
125 return implode('', $fragments);
129 * Takes a variable name and munges it randomly into another variable name.
131 * @param string $name
132 * Initial Variable Name.
134 * Length of valid variables.
137 * Randomized Variable Name
139 public static function rename($name, $len = 4) {
140 $rand = substr(uniqid(), 0, $len);
141 return substr_replace($name, $rand, -$len, $len);
145 * Takes a string and returns the last tuple of the string.
147 * Useful while converting file names to class names etc
149 * @param string $string
151 * @param string $char
152 * Character used to demarcate the components
157 public static function getClassName($string, $char = '_') {
159 if (!is_array($string)) {
160 $names = explode($char, $string);
162 if (!empty($names)) {
163 return array_pop($names);
168 * Appends a name to a string and separated by delimiter.
170 * Does the right thing for an empty string
173 * The string to be appended to.
174 * @param string $delim
175 * The delimiter to use.
177 * The string (or array of strings) to append.
179 public static function append(&$str, $delim, $name) {
184 if (is_array($name)) {
185 foreach ($name as $n) {
202 $str .= $delim . $name;
208 * Determine if the string is composed only of ascii characters.
213 * Attempt utf8 match on failure (default yes).
216 * true if string is ascii
218 public static function isAscii($str, $utf8 = TRUE) {
219 if (!function_exists('mb_detect_encoding')) {
220 // eliminate all white space from the string
221 $str = preg_replace('/\s+/', '', $str);
222 // FIXME: This is a pretty brutal hack to make utf8 and 8859-1 work.
224 /* match low- or high-ascii characters */
225 if (preg_match('/[\x00-\x20]|[\x7F-\xFF]/', $str)) {
226 // || // low ascii characters
227 // high ascii characters
228 // preg_match( '/[\x7F-\xFF]/', $str ) ) {
230 /* if we did match, try for utf-8, or iso8859-1 */
232 return self
::isUtf8($str);
241 $order = array('ASCII');
245 $enc = mb_detect_encoding($str, $order, TRUE);
246 return ($enc == 'ASCII' ||
$enc == 'UTF-8');
251 * Determine the string replacements for redaction.
252 * on the basis of the regular expressions
256 * @param array $regexRules
257 * Regular expression to be matched w/ replacements.
260 * array of strings w/ corresponding redacted outputs
262 public static function regex($str, $regexRules) {
263 //redact the regular expressions
264 if (!empty($regexRules) && isset($str)) {
265 static $matches, $totalMatches, $match = array();
266 foreach ($regexRules as $pattern => $replacement) {
267 preg_match_all($pattern, $str, $matches);
268 if (!empty($matches[0])) {
269 if (empty($totalMatches)) {
270 $totalMatches = $matches[0];
273 $totalMatches = array_merge($totalMatches, $matches[0]);
275 $match = array_flip($totalMatches);
280 if (!empty($match)) {
281 foreach ($match as $matchKey => & $dontCare) {
282 foreach ($regexRules as $pattern => $replacement) {
283 if (preg_match($pattern, $matchKey)) {
284 $dontCare = $replacement . substr(md5($matchKey), 0, 5);
291 return CRM_Core_DAO
::$_nullArray;
296 * @param $stringRules
300 public static function redaction($str, $stringRules) {
302 if (!empty($stringRules)) {
303 foreach ($stringRules as $match => $replace) {
304 $str = str_ireplace($match, $replace, $str);
308 //return the redacted output
313 * Determine if a string is composed only of utf8 characters
320 public static function isUtf8($str) {
321 if (!function_exists(mb_detect_encoding
)) {
322 // eliminate all white space from the string
323 $str = preg_replace('/\s+/', '', $str);
325 /* pattern stolen from the php.net function documentation for
327 * comment by JF Sebastian, 30-Mar-2005
330 return preg_match('/^([\x00-\x7f]|[\xc2-\xdf][\x80-\xbf]|\xe0[\xa0-\xbf][\x80-\xbf]|[\xe1-\xec][\x80-\xbf]{2}|\xed[\x80-\x9f][\x80-\xbf]|[\xee-\xef][\x80-\xbf]{2}|f0[\x90-\xbf][\x80-\xbf]{2}|[\xf1-\xf3][\x80-\xbf]{3}|\xf4[\x80-\x8f][\x80-\xbf]{2})*$/', $str);
332 // iconv('ISO-8859-1', 'UTF-8', $str);
335 $enc = mb_detect_encoding($str, array('UTF-8'), TRUE);
336 return ($enc !== FALSE);
341 * Determine if two href's are equivalent (fuzzy match)
343 * @param string $url1
344 * The first url to be matched.
345 * @param string $url2
346 * The second url to be matched against.
349 * true if the urls match, else false
351 public static function match($url1, $url2) {
352 $url1 = strtolower($url1);
353 $url2 = strtolower($url2);
355 $url1Str = parse_url($url1);
356 $url2Str = parse_url($url2);
358 if ($url1Str['path'] == $url2Str['path'] &&
359 self
::extractURLVarValue(CRM_Utils_Array
::value('query', $url1Str)) == self
::extractURLVarValue(CRM_Utils_Array
::value('query', $url2Str))
367 * Extract the civicrm path from the url.
369 * @param string $query
372 * @return string|null
373 * civicrm url (eg: civicrm/contact/search)
375 public static function extractURLVarValue($query) {
376 $config = CRM_Core_Config
::singleton();
377 $urlVar = $config->userFrameworkURLVar
;
379 $params = explode('&', $query);
380 foreach ($params as $p) {
381 if (strpos($p, '=')) {
382 list($k, $v) = explode('=', $p);
392 * Translate a true/false/yes/no string to a 0 or 1 value
395 * The string to be translated.
399 public static function strtobool($str) {
400 if (!is_scalar($str)) {
404 if (preg_match('/^(y(es)?|t(rue)?|1)$/i', $str)) {
411 * Returns string '1' for a true/yes/1 string, and '0' for no/false/0 else returns false
414 * The string to be translated.
418 public static function strtoboolstr($str) {
419 if (!is_scalar($str)) {
423 if (preg_match('/^(y(es)?|t(rue)?|1)$/i', $str)) {
426 elseif (preg_match('/^(n(o)?|f(alse)?|0)$/i', $str)) {
435 * Convert a HTML string into a text one using html2text
437 * @param string $html
438 * The string to be converted.
441 * the converted string
443 public static function htmlToText($html) {
444 require_once 'packages/html2text/rcube_html2text.php';
445 $token_html = preg_replace('!\{([a-z_.]+)\}!i', 'token:{$1}', $html);
446 $converter = new rcube_html2text($token_html);
447 $token_text = $converter->get_text();
448 $text = preg_replace('!token\:\{([a-z_.]+)\}!i', '{$1}', $token_text);
454 * @param array $params
456 public static function extractName($string, &$params) {
457 $name = trim($string);
463 $name = str_replace('"', '', $name);
464 $name = str_replace('\'', '', $name);
466 // check for comma in name
467 if (strpos($name, ',') !== FALSE) {
469 // name has a comma - assume lname, fname [mname]
470 $names = explode(',', $name);
471 if (count($names) > 1) {
472 $params['last_name'] = trim($names[0]);
474 // check for space delim
475 $fnames = explode(' ', trim($names[1]));
476 if (count($fnames) > 1) {
477 $params['first_name'] = trim($fnames[0]);
478 $params['middle_name'] = trim($fnames[1]);
481 $params['first_name'] = trim($fnames[0]);
485 $params['first_name'] = trim($names[0]);
489 // name has no comma - assume fname [mname] fname
490 $names = explode(' ', $name);
491 if (count($names) == 1) {
492 $params['first_name'] = $names[0];
494 elseif (count($names) == 2) {
495 $params['first_name'] = $names[0];
496 $params['last_name'] = $names[1];
499 $params['first_name'] = $names[0];
500 $params['middle_name'] = $names[1];
501 $params['last_name'] = $names[2];
511 public static function &makeArray($string) {
512 $string = trim($string);
514 $values = explode("\n", $string);
516 foreach ($values as $value) {
517 list($n, $v) = CRM_Utils_System
::explode('=', $value, 2);
519 $result[trim($n)] = trim($v);
526 * Given an ezComponents-parsed representation of
527 * a text with alternatives return only the first one
529 * @param string $full
530 * All alternatives as a long string (or some other text).
533 * only the first alternative found (or the text without alternatives)
535 public static function stripAlternatives($full) {
537 preg_match('/-ALTERNATIVE ITEM 0-(.*?)-ALTERNATIVE ITEM 1-.*-ALTERNATIVE END-/s', $full, $matches);
539 if (isset($matches[1]) &&
540 trim(strip_tags($matches[1])) != ''
550 * Strip leading, trailing, double spaces from string
551 * used for postal/greeting/addressee
553 * @param string $string
554 * Input string to be cleaned.
559 public static function stripSpaces($string) {
560 return (empty($string)) ?
$string : preg_replace("/\s{2,}/", " ", trim($string));
564 * clean the URL 'path' variable that we use
565 * to construct CiviCRM urls by removing characters from the path variable
567 * @param string $string
568 * The input string to be sanitized.
569 * @param array $search
570 * The characters to be sanitized.
571 * @param string $replace
572 * The character to replace it with.
575 * the sanitized string
577 public static function stripPathChars(
582 static $_searchChars = NULL;
583 static $_replaceChar = NULL;
585 if (empty($string)) {
589 if ($_searchChars == NULL) {
590 $_searchChars = array(
612 if ($search == NULL) {
613 $search = $_searchChars;
616 if ($replace == NULL) {
617 $replace = $_replaceChar;
620 return str_replace($search, $replace, $string);
625 * Use HTMLPurifier to clean up a text string and remove any potential
626 * xss attacks. This is primarily used in public facing pages which
627 * accept html as the input string
629 * @param string $string
633 * the cleaned up string
635 public static function purifyHTML($string) {
636 static $_filter = NULL;
638 $config = HTMLPurifier_Config
::createDefault();
639 $config->set('Core.Encoding', 'UTF-8');
641 // Disable the cache entirely
642 $config->set('Cache.DefinitionImpl', NULL);
644 $_filter = new HTMLPurifier($config);
647 return $_filter->purify($string);
651 * Truncate $string; if $string exceeds $maxLen, place "..." at the end
653 * @param string $string
658 public static function ellipsify($string, $maxLen) {
659 $len = strlen($string);
660 if ($len <= $maxLen) {
664 return substr($string, 0, $maxLen - 3) . '...';
669 * Generate a random string.
675 public static function createRandom($len, $alphabet) {
676 $alphabetSize = strlen($alphabet);
678 for ($i = 0; $i < $len; $i++
) {
679 $result .= $alphabet{rand(1, $alphabetSize) - 1};
686 * "admin foo" => array(NULL,"admin foo")
687 * "cms:admin foo" => array("cms", "admin foo")
690 * @param string $string
691 * E.g. "view all contacts". Syntax: "[prefix:]name".
692 * @param null $defaultPrefix
695 * (0 => string|NULL $prefix, 1 => string $value)
697 public static function parsePrefix($delim, $string, $defaultPrefix = NULL) {
698 $pos = strpos($string, $delim);
699 if ($pos === FALSE) {
700 return array($defaultPrefix, $string);
703 return array(substr($string, 0, $pos), substr($string, 1 +
$pos));
708 * This function will mask part of the the user portion of an Email address (everything before the @)
710 * @param string $email
711 * The email address to be masked.
712 * @param string $maskChar
713 * The character used for masking.
714 * @param int $percent
715 * The percentage of the user portion to be masked.
718 * returns the masked Email address
720 public static function maskEmail($email, $maskChar = '*', $percent = 50) {
721 list($user, $domain) = preg_split("/@/", $email);
722 $len = strlen($user);
723 $maskCount = floor($len * $percent / 100);
724 $offset = floor(($len - $maskCount) / 2);
726 $masked = substr($user, 0, $offset)
727 . str_repeat($maskChar, $maskCount)
728 . substr($user, $maskCount +
$offset);
730 return ($masked . '@' . $domain);
734 * This function compares two strings.
736 * @param string $strOne
738 * @param string $strTwo
741 * Boolean indicating whether you want the comparison to be case sensitive or not.
744 * TRUE (string are identical); FALSE (strings are not identical)
746 public static function compareStr($strOne, $strTwo, $case) {
748 // Convert to lowercase and trim white spaces
749 if (strtolower(trim($strOne)) == strtolower(trim($strTwo))) {
750 // yes - they are identical
758 if ($case == FALSE) {
760 if (trim($strOne) == trim($strTwo)) {
761 // yes - they are identical
772 * Many parts of the codebase have a convention of internally passing around
773 * HTML-encoded URLs. This effectively means that "&" is replaced by "&"
774 * (because most other odd characters are %-escaped in URLs; and %-escaped
775 * strings don't need any extra escaping in HTML).
777 * @param string $htmlUrl
778 * URL with HTML entities.
780 * URL without HTML entities
782 public static function unstupifyUrl($htmlUrl) {
783 return str_replace('&', '&', $htmlUrl);
787 * Formats a string of attributes for insertion in an html tag.
789 * @param array $attributes
793 public static function htmlAttributes($attributes) {
795 foreach ($attributes as $name => $vals) {
796 $output .= " $name=\"" . htmlspecialchars(implode(' ', (array) $vals)) . '"';
798 return ltrim($output);