PKPString.inc.php

<?php
 
/*
 * Perl-compatibile regular expression (PCRE) constants:
 * These are defined application-wide for consistency
 */
 
/*
 * RFC-2396 URIs
 *
 * Thanks to the PEAR Validation package (Tomas V.V.Cox <cox@idecnet.com>,
 * Pierre-Alain Joye <pajoye@php.net>, Amir Mohammad Saied <amir@php.net>)
 *
 * Originally published under the "New BSD License"
 * http://www.opensource.org/licenses/bsd-license.php
 */
define('PCRE_URI', '(?:([a-z][-+.a-z0-9]*):)?' .                  // Scheme
         '(?://' .
         '(?:((?:%[0-9a-f]{2}|[-a-z0-9_.!~*\'();:\&=+$,])*)@)?' .       // User
         '(?:((?:[a-z0-9](?:[-a-z0-9]*[a-z0-9])?\.)*[a-z](?:[a-z0-9]+)?\.?)' .   // Hostname
         '|([0-9]{1,3}(?:\.[0-9]{1,3}){3}))' .              // IP Address
         '(?::([0-9]*))?)' .                       // Port
         '((?:/(?:%[0-9a-f]{2}|[-a-z0-9_.!~*\'():@\&=+$,;])*)*/?)?' .         // Path
         '(?:\?([^#]*))?' .                        // Query String
         '(?:\#((?:%[0-9a-f]{2}|[-a-z0-9_.!~*\'();/?:@\&=+$,])*))?');         // Fragment
 
// Two different types of camel case: one for class names and one for method names
define ('CAMEL_CASE_HEAD_UP', 0x01);
define ('CAMEL_CASE_HEAD_DOWN', 0x02);
 
class PKPString {
   static function init() {
      $clientCharset = strtolower_codesafe(Config::getVar('i18n', 'client_charset'));
 
      // Check if mbstring is installed
      if (self::hasMBString() && !defined('ENABLE_MBSTRING')) {
         // mbstring routines are available
         define('ENABLE_MBSTRING', true);
 
         // Set up required ini settings for mbstring
         // FIXME Do any other mbstring settings need to be set?
         mb_internal_encoding($clientCharset);
         mb_substitute_character('63');      // question mark
      }
 
      // Define modifier to be used in regexp_* routines
      // FIXME Should non-UTF-8 encodings be supported with mbstring?
      if (!defined('PCRE_UTF8')) {
         if ($clientCharset == 'utf-8' && self::hasPCREUTF8()) {
            define('PCRE_UTF8', 'u');
         } else {
            define('PCRE_UTF8', '');
         }
      }
   }
 
   static function hasMBString() {
      static $hasMBString;
      if (isset($hasMBString)) return $hasMBString;
 
      // If string overloading is active, it will break many of the
      // native implementations. mbstring.func_overload must be set
      // to 0, 1 or 4 in php.ini (string overloading disabled).
      if (ini_get('mbstring.func_overload') && defined('MB_OVERLOAD_STRING')) {
         $hasMBString = false;
      } else {
         $hasMBString = (
            extension_loaded('mbstring') &&
            function_exists('mb_strlen') &&
            function_exists('mb_strpos') &&
            function_exists('mb_strrpos') &&
            function_exists('mb_substr') &&
            function_exists('mb_strtolower') &&
            function_exists('mb_strtoupper') &&
            function_exists('mb_substr_count') &&
            function_exists('mb_send_mail')
         );
      }
      return $hasMBString;
   }
 
   static function hasPCREUTF8() {
      // The PCRE_UTF8 modifier is only supported on PHP >= 4.1.0 (*nix) or PHP >= 4.2.3 (win32)
      // Evil check to see if PCRE_UTF8 is supported
      if (@preg_match('//u', '')) {
         return true;
      } else {
         return false;
      }
   }
 
   //
   // Wrappers for basic string manipulation routines.
   //
 
   static function strlen($string) {
      return Stringy\Stringy::create($string)->length();
   }
 
   static function strpos($haystack, $needle, $offset = 0) {
      return Stringy\Stringy::create($haystack)->indexOf($needle, $offset);
   }
 
   static function strrpos($haystack, $needle) {
      return Stringy\Stringy::create($haystack)->indexOfLast($needle);
   }
 
   static function substr($string, $start, $length = null) {
      return (string) Stringy\Stringy::create($string)->substr($start, $length);
   }
 
   static function strtolower($string) {
      return (string) Stringy\Stringy::create($string)->toLowerCase();
   }
 
   static function strtoupper($string) {
      return (string) Stringy\Stringy::create($string)->toUpperCase();
   }
 
   static function ucfirst($string) {
      return (string) Stringy\Stringy::create($string)->upperCaseFirst();
   }
 
   static function substr_count($haystack, $needle) {
      return Stringy\Stringy::create($haystack)->countSubstring($needle);
   }
 
   static function encode_mime_header($string) {
      if (defined('ENABLE_MBSTRING')) {
         return mb_encode_mimeheader($string, mb_internal_encoding(), 'B', MAIL_EOL);
      }  else {
         return $string;
      }
   }
 
   //
   // Wrappers for PCRE-compatible regular expression routines.
   // See the php.net documentation for usage.
   //
 
   static function regexp_quote($string, $delimiter = '/') {
      return preg_quote($string, $delimiter);
   }
 
   static function regexp_grep($pattern, $input) {
      return preg_grep($pattern . PCRE_UTF8, $input);
   }
 
   static function regexp_match($pattern, $subject) {
      return preg_match($pattern . PCRE_UTF8, $subject);
   }
 
   static function regexp_match_get($pattern, $subject, &$matches) {
      return preg_match($pattern . PCRE_UTF8, $subject, $matches);
   }
 
   static function regexp_match_all($pattern, $subject, &$matches) {
      return preg_match_all($pattern . PCRE_UTF8, $subject, $matches);
   }
 
   static function regexp_replace($pattern, $replacement, $subject, $limit = -1) {
      return preg_replace($pattern . PCRE_UTF8, $replacement, $subject, $limit);
   }
 
   static function regexp_replace_callback($pattern, $callback, $subject, $limit = -1) {
      return preg_replace_callback($pattern . PCRE_UTF8, $callback, $subject, $limit);
   }
 
   static function regexp_split($pattern, $subject, $limit = -1) {
      return preg_split($pattern . PCRE_UTF8, $subject, $limit);
   }
 
   static function mime_content_type($filename, $suggestedExtension = '') {
      $result = null;
 
      if (function_exists('finfo_open')) {
         $fi =& Registry::get('fileInfo', true, null);
         if ($fi === null) {
            $fi = finfo_open(FILEINFO_MIME, Config::getVar('finfo', 'mime_database_path'));
         }
         if ($fi !== false) {
            $result = strtok(finfo_file($fi, $filename), ' ;');
         }
      }
 
      if (!$result && function_exists('mime_content_type')) {
         $result = mime_content_type($filename);
         // mime_content_type appears to return a charset
         // (erroneously?) in recent versions of PHP5
         if (($i = strpos($result, ';')) !== false) {
            $result = trim(substr($result, 0, $i));
         }
      }
 
      if (!$result) {
         // Fall back on an external "file" tool
         $f = escapeshellarg($filename);
         $result = trim(`file --brief --mime $f`);
         // Make sure we just return the mime type.
         if (($i = strpos($result, ';')) !== false) {
            $result = trim(substr($result, 0, $i));
         }
      }
 
      // Check ambiguous mimetypes against extension
      $exploded = explode('.',$filename);
      $ext = array_pop($exploded);
      if ($suggestedExtension) {
         $ext = $suggestedExtension;
      }
      // SUGGESTED_EXTENSION:DETECTED_MIME_TYPE => OVERRIDE_MIME_TYPE
      $ambiguities = array(
         'html:text/xml' => 'text/html',
         'css:text/x-c' => 'text/css',
         'css:text/plain' => 'text/css',
         'xlsx:application/zip' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
         'xltx:application/zip' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.template',
         'potx:application/zip' => 'application/vnd.openxmlformats-officedocument.presentationml.template',
         'ppsx:application/zip' => 'application/vnd.openxmlformats-officedocument.presentationml.slideshow',
         'pptx:application/zip' => 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
         'sldx:application/zip' => 'application/vnd.openxmlformats-officedocument.presentationml.slide',
         'docx:application/zip' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
         'dotx:application/zip' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
      );
      if (isset($ambiguities[strtolower($ext.':'.$result)])) {
         $result = $ambiguities[strtolower($ext.':'.$result)];
      }
 
      return $result;
   }
 
   static function stripUnsafeHtml($input) {
      static $purifier;
      if (!isset($purifier)) {
         $config = HTMLPurifier_Config::createDefault();
         $config->set('Core.Encoding', Config::getVar('i18n', 'client_charset'));
         $config->set('HTML.Doctype', 'HTML 4.01 Transitional');
         $config->set('HTML.Allowed', Config::getVar('security', 'allowed_html'));
         $config->set('Cache.SerializerPath', 'cache');
         $purifier = new HTMLPurifier($config);
      }
      return $purifier->purify($input);
   }
 
   static function html2text($html) {
      $html = self::regexp_replace('/<[\/]?p>/', "\n", $html);
      $html = self::regexp_replace('/<li>/', '&bull; ', $html);
      $html = self::regexp_replace('/<\/li>/', "\n", $html);
      $html = self::regexp_replace('/<br[ ]?[\/]?>/', "\n", $html);
      $html = html_entity_decode(strip_tags($html), ENT_COMPAT, 'UTF-8');
      return $html;
   }
 
   static function concatTitleFields($fields) {
      // Set the characters that will avoid the use of
      // a semicolon between title and subtitle.
      $avoidColonChars = array('?', '!', '/', '&');
 
      // if the first field ends in a character in $avoidColonChars,
      // concat with a space, otherwise use a colon.
      // Check for any of these characters in
      // the last position of current full title value.
      if (in_array(substr($fields[0], -1, 1), $avoidColonChars)) {
         $fullTitle = join(' ', $fields);
      } else {
         $fullTitle = join(': ', $fields);
      }
 
      return $fullTitle;
   }
 
   static function camelize($string, $type = CAMEL_CASE_HEAD_UP) {
      assert($type == CAMEL_CASE_HEAD_UP || $type == CAMEL_CASE_HEAD_DOWN);
 
      // Transform "handler-class" to "HandlerClass" and "my-op" to "MyOp"
      $string = implode(array_map('ucfirst_codesafe', explode('-', $string)));
 
      // Transform "MyOp" to "myOp"
      if ($type == CAMEL_CASE_HEAD_DOWN) {
         $string = strtolower_codesafe(substr($string, 0, 1)).substr($string, 1);
      }
 
      return $string;
   }
 
   static function uncamelize($string) {
      assert(!empty($string));
 
      // Transform "myOp" to "MyOp"
      $string = ucfirst_codesafe($string);
 
      // Insert hyphens between words and return the string in lowercase
      $words = array();
      self::regexp_match_all('/[A-Z][a-z0-9]*/', $string, $words);
      assert(isset($words[0]) && !empty($words[0]) && strlen(implode('', $words[0])) == strlen($string));
      return strtolower_codesafe(implode('-', $words[0]));
   }
 
   static function enumerateAlphabetically($steps) {
      return chr(ord('A') + $steps);
   }
 
   static function generateUUID() {
      mt_srand((double)microtime()*10000);
      $charid = strtoupper(md5(uniqid(rand(), true)));
      $hyphen = '-';
      $uuid = substr($charid, 0, 8).$hyphen
            .substr($charid, 8, 4).$hyphen
            .'4'.substr($charid,13, 3).$hyphen
            .strtoupper(dechex(hexdec(ord(substr($charid,16,1))) % 4 + 8)).substr($charid,17, 3).$hyphen
            .substr($charid,20,12);
      return $uuid;
   }
 
   static function dateformatPHP2JQueryDatepicker($phpFormat) {
      $symbols = array(
         // Day
         'a' => 'D', // date() format 'D'
         'A' => 'DD',   // date() format 'DD'
         'd' => 'dd',   // date() format 'd'
         'e' => 'd', // date() format 'j'
         'j' => 'oo',   // date() format none
         'u' => '',     // date() format 'N'
         'w' => '',     // date() format 'w'
 
         // Week
         'U' => '',     // date() format none
         'V' => '',     // date() format none
         'W' => '',     // date() format 'W'
 
         // Month
         'b' => 'M', // date() format 'M'
         'h' => 'M', // date() format 'M'
         'B' => 'MM',   // date() format 'F'
         'm' => 'mm',   // date() format 'm'
 
         // Year
         'C' => '',     // date() format none
         'g' => 'y', // date() format none
         'G' => 'yy',   // date() format 'o'
         'y' => 'y', // date() format 'y'
         'Y' => 'yy',   // date() format 'Y'
 
         // Time
         'H' => '',     // date() format 'H'
         'k' => '',     // date() format none
         'I' => '',     // date() format 'h'
         'l' => '',     // date() format 'g'
         'P' => '',     // date() format 'a'
         'p' => '',     // date() format 'A'
         'M' => '',     // date() format 'i'
         'S' => '',     // date() format 's'
         's' => '',     // date() format 'u'
 
         // Timezone
         'z' => '',     // date() format 'O'
         'Z' => '',     // date() format 'T'
 
         // Full Date/Time
         'r' => '',     // date() format none
         'R' => '',     // date() format none
         'X' => '',     // date() format none
         'D' => '',     // date() format none
         'F' => '',     // date() format none
         'x' => '',     // date() format none
         'c' => '',     // date() format none
 
         // Other
         '%' => ''
      );
 
      $datepickerFormat = "";
      $escaping = false;
 
      for ($i = 0; $i < strlen($phpFormat); $i++) {
         $char = $phpFormat[$i];
         if($char === '\\') {
            $i++;
            $datepickerFormat .= $escaping ? $phpFormat[$i] : '\'' . $phpFormat[$i];
 
            $escaping = true;
         } else {
            if($escaping) {
               $datepickerFormat .= "'";
               $escaping = false;
            }
 
            $datepickerFormat .= isset($symbols[$char]) ? $symbols[$char] : $char;
 
         }
      }
 
      return $datepickerFormat;
   }
}