Mistralys / application-utils

src/ConvertHelper.php

Indentation +374 added lines, -374 removed lines

@@ -426,16 +426,16 @@ 
         return $bytes . ' ' . t('B');
     }
 
-   /**
-    * Cuts a text to the specified length if it is longer than the
-    * target length. Appends a text to signify it has been cut at 
-    * the end of the string.
-    * 
-    * @param string $text
-    * @param int $targetLength
-    * @param string $append
-    * @return string
-    */
+    /**
+     * Cuts a text to the specified length if it is longer than the
+     * target length. Appends a text to signify it has been cut at 
+     * the end of the string.
+     * 
+     * @param string $text
+     * @param int $targetLength
+     * @param string $append
+     * @return string
+     */
     public static function text_cut(string $text, int $targetLength, string $append = '...') : string
     {
         $length = mb_strlen($text);
@@ -505,27 +505,27 @@ 
         return self::$booleanStrings[$string];
     }
     
-   /**
-    * Whether the specified string is a boolean string or boolean value.
-    * Alias for {@link ConvertHelper::isBoolean()}.
-    * 
-    * @param mixed $string
-    * @return bool
-    * @deprecated
-    * @see ConvertHelper::isBoolean()
-    */
+    /**
+     * Whether the specified string is a boolean string or boolean value.
+     * Alias for {@link ConvertHelper::isBoolean()}.
+     * 
+     * @param mixed $string
+     * @return bool
+     * @deprecated
+     * @see ConvertHelper::isBoolean()
+     */
     public static function isBooleanString($string) : bool
     {
         return self::isBoolean($string);
     }
 
-   /**
-    * Alias for the {@\AppUtils\XMLHelper::string2xml()} method.
-    * 
-    * @param string $text
-    * @return string
-    * @deprecated
-    */
+    /**
+     * Alias for the {@\AppUtils\XMLHelper::string2xml()} method.
+     * 
+     * @param string $text
+     * @return string
+     * @deprecated
+     */
     public static function text_makeXMLCompliant($text)
     {
         return XMLHelper::string2xml($text);
@@ -627,13 +627,13 @@ 
         return $translit->convert($string);
     }
     
-   /**
-    * Retrieves the HEX character codes for all control
-    * characters that the {@link stripControlCharacters()} 
-    * method will remove.
-    * 
-    * @return string[]
-    */
+    /**
+     * Retrieves the HEX character codes for all control
+     * characters that the {@link stripControlCharacters()} 
+     * method will remove.
+     * 
+     * @return string[]
+     */
     public static function getControlCharactersAsHex()
     {
         $hexAlphabet = array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F');
@@ -669,13 +669,13 @@ 
         return $stack;
     }
     
-   /**
-    * Retrieves an array of all control characters that
-    * the {@link stripControlCharacters()} method will 
-    * remove, as the actual UTF-8 characters.
-    * 
-    * @return string[]
-    */
+    /**
+     * Retrieves an array of all control characters that
+     * the {@link stripControlCharacters()} method will 
+     * remove, as the actual UTF-8 characters.
+     * 
+     * @return string[]
+     */
     public static function getControlCharactersAsUTF8()
     {
         $chars = self::getControlCharactersAsHex();
@@ -688,12 +688,12 @@ 
         return $result;
     }
     
-   /**
-    * Retrieves all control characters as JSON encoded
-    * characters, e.g. "\u200b".
-    * 
-    * @return string[]
-    */
+    /**
+     * Retrieves all control characters as JSON encoded
+     * characters, e.g. "\u200b".
+     * 
+     * @return string[]
+     */
     public static function getControlCharactersAsJSON()
     {
         $chars = self::getControlCharactersAsHex();
@@ -750,20 +750,20 @@ 
         return preg_replace(self::$controlCharsRegex, '', $string);
     }
 
-   /**
-    * Converts a unicode character to the PHPO notation.
-    * 
-    * Example:
-    * 
-    * <pre>unicodeChar2php('"\u0000"')</pre>
-    * 
-    * Returns
-    * 
-    * <pre>\x0</pre>
-    * 
-    * @param string $unicodeChar
-    * @return string
-    */
+    /**
+     * Converts a unicode character to the PHPO notation.
+     * 
+     * Example:
+     * 
+     * <pre>unicodeChar2php('"\u0000"')</pre>
+     * 
+     * Returns
+     * 
+     * <pre>\x0</pre>
+     * 
+     * @param string $unicodeChar
+     * @return string
+     */
     public static function unicodeChar2php($unicodeChar) 
     {
         $unicodeChar = json_decode($unicodeChar);
@@ -886,25 +886,25 @@ 
         return 'false';
     }
     
-   /**
-    * Converts an associative array with attribute name > value pairs
-    * to an attribute string that can be used in an HTML tag. Empty 
-    * attribute values are ignored.
-    * 
-    * Example:
-    * 
-    * array2attributeString(array(
-    *     'id' => 45,
-    *     'href' => 'http://www.mistralys.com'
-    * ));
-    * 
-    * Result:
-    * 
-    * id="45" href="http://www.mistralys.com"
-    * 
-    * @param array $array
-    * @return string
-    */
+    /**
+     * Converts an associative array with attribute name > value pairs
+     * to an attribute string that can be used in an HTML tag. Empty 
+     * attribute values are ignored.
+     * 
+     * Example:
+     * 
+     * array2attributeString(array(
+     *     'id' => 45,
+     *     'href' => 'http://www.mistralys.com'
+     * ));
+     * 
+     * Result:
+     * 
+     * id="45" href="http://www.mistralys.com"
+     * 
+     * @param array $array
+     * @return string
+     */
     public static function array2attributeString($array)
     {
         $tokens = array();
@@ -923,14 +923,14 @@ 
         return ' '.implode(' ', $tokens);
     }
     
-   /**
-    * Converts a string so it can safely be used in a javascript
-    * statement in an HTML tag: uses single quotes around the string
-    * and encodes all special characters as needed.
-    * 
-    * @param string $string
-    * @return string
-    */
+    /**
+     * Converts a string so it can safely be used in a javascript
+     * statement in an HTML tag: uses single quotes around the string
+     * and encodes all special characters as needed.
+     * 
+     * @param string $string
+     * @return string
+     */
     public static function string2attributeJS($string, $quoted=true)
     {
         $converted = addslashes(htmlspecialchars(strip_tags($string), ENT_QUOTES, 'UTF-8'));
@@ -941,15 +941,15 @@ 
         return $converted;
     }
     
-   /**
-    * Checks if the specified string is a boolean value, which
-    * includes string representations of boolean values, like 
-    * <code>yes</code> or <code>no</code>, and <code>true</code>
-    * or <code>false</code>.
-    * 
-    * @param mixed $value
-    * @return boolean
-    */
+    /**
+     * Checks if the specified string is a boolean value, which
+     * includes string representations of boolean values, like 
+     * <code>yes</code> or <code>no</code>, and <code>true</code>
+     * or <code>false</code>.
+     * 
+     * @param mixed $value
+     * @return boolean
+     */
     public static function isBoolean($value) : bool
     {
         if(is_bool($value)) {
@@ -963,12 +963,12 @@ 
         return array_key_exists($value, self::$booleanStrings);
     }
     
-   /**
-    * Converts an associative array to an HTML style attribute value string.
-    * 
-    * @param array $subject
-    * @return string
-    */
+    /**
+     * Converts an associative array to an HTML style attribute value string.
+     * 
+     * @param array $subject
+     * @return string
+     */
     public static function array2styleString(array $subject) : string
     {
         $tokens = array();
@@ -979,23 +979,23 @@ 
         return implode(';', $tokens);
     }
     
-   /**
-    * Converts a DateTime object to a timestamp, which
-    * is PHP 5.2 compatible.
-    * 
-    * @param \DateTime $date
-    * @return integer
-    */
+    /**
+     * Converts a DateTime object to a timestamp, which
+     * is PHP 5.2 compatible.
+     * 
+     * @param \DateTime $date
+     * @return integer
+     */
     public static function date2timestamp(\DateTime $date) : int
     {
         return (int)$date->format('U');
     }
     
-   /**
-    * Converts a timestamp into a DateTime instance.
-    * @param int $timestamp
-    * @return \DateTime
-    */
+    /**
+     * Converts a timestamp into a DateTime instance.
+     * @param int $timestamp
+     * @return \DateTime
+     */
     public static function timestamp2date(int $timestamp) : \DateTime
     {
         $date = new \DateTime();
@@ -1003,50 +1003,50 @@ 
         return $date;
     }
     
-   /**
-    * Strips an absolute path to a file within the application
-    * to make the path relative to the application root path.
-    * 
-    * @param string $path
-    * @return string
-    * 
-    * @see FileHelper::relativizePath()
-    * @see FileHelper::relativizePathByDepth()
-    */
+    /**
+     * Strips an absolute path to a file within the application
+     * to make the path relative to the application root path.
+     * 
+     * @param string $path
+     * @return string
+     * 
+     * @see FileHelper::relativizePath()
+     * @see FileHelper::relativizePathByDepth()
+     */
     public static function fileRelativize(string $path) : string
     {
         return FileHelper::relativizePathByDepth($path);
     }
     
     /**
-    * Converts a PHP regex to a javascript RegExp object statement.
-    * 
-    * NOTE: This is an alias for the JSHelper's `convertRegex` method. 
-    * More details are available on its usage there.
-    *
-    * @param string $regex A PHP preg regex
-    * @param string $statementType The type of statement to return: Defaults to a statement to create a RegExp object.
-    * @return array|string Depending on the specified return type.
-    * 
-    * @see JSHelper::buildRegexStatement()
-    */
+     * Converts a PHP regex to a javascript RegExp object statement.
+     * 
+     * NOTE: This is an alias for the JSHelper's `convertRegex` method. 
+     * More details are available on its usage there.
+     *
+     * @param string $regex A PHP preg regex
+     * @param string $statementType The type of statement to return: Defaults to a statement to create a RegExp object.
+     * @return array|string Depending on the specified return type.
+     * 
+     * @see JSHelper::buildRegexStatement()
+     */
     public static function regex2js(string $regex, string $statementType=JSHelper::JS_REGEX_OBJECT)
     {
         return JSHelper::buildRegexStatement($regex, $statementType);
     }
     
-   /**
-    * Converts the specified variable to JSON. Works just
-    * like the native `json_encode` method, except that it
-    * will trigger an exception on failure, which has the 
-    * json error details included in its developer details.
-    * 
-    * @param mixed $variable
-    * @param int|NULL $options JSON encode options.
-    * @param int|NULL $depth 
-    * @throws ConvertHelper_Exception
-    * @return string
-    */
+    /**
+     * Converts the specified variable to JSON. Works just
+     * like the native `json_encode` method, except that it
+     * will trigger an exception on failure, which has the 
+     * json error details included in its developer details.
+     * 
+     * @param mixed $variable
+     * @param int|NULL $options JSON encode options.
+     * @param int|NULL $depth 
+     * @throws ConvertHelper_Exception
+     * @return string
+     */
     public static function var2json($variable, int $options=0, int $depth=512) : string
     {
         $result = json_encode($variable, $options, $depth);
@@ -1067,12 +1067,12 @@ 
         );
     }
     
-   /**
-    * Strips all known UTF byte order marks from the specified string.
-    * 
-    * @param string $string
-    * @return string
-    */
+    /**
+     * Strips all known UTF byte order marks from the specified string.
+     * 
+     * @param string $string
+     * @return string
+     */
     public static function stripUTFBom($string)
     {
         $boms = FileHelper::getUTFBOMs();
@@ -1087,13 +1087,13 @@ 
         return $string;
     }
 
-   /**
-    * Converts a string to valid utf8, regardless
-    * of the string's encoding(s).
-    * 
-    * @param string $string
-    * @return string
-    */
+    /**
+     * Converts a string to valid utf8, regardless
+     * of the string's encoding(s).
+     * 
+     * @param string $string
+     * @return string
+     */
     public static function string2utf8($string)
     {
         if(!self::isStringASCII($string)) {
@@ -1103,15 +1103,15 @@ 
         return $string;
     }
     
-   /**
-    * Checks whether the specified string is an ASCII
-    * string, without any special or UTF8 characters.
-    * Note: empty strings and NULL are considered ASCII.
-    * Any variable types other than strings are not.
-    * 
-    * @param string $string
-    * @return boolean
-    */
+    /**
+     * Checks whether the specified string is an ASCII
+     * string, without any special or UTF8 characters.
+     * Note: empty strings and NULL are considered ASCII.
+     * Any variable types other than strings are not.
+     * 
+     * @param string $string
+     * @return boolean
+     */
     public static function isStringASCII($string)
     {
         if($string === '' || $string === NULL) {
@@ -1136,22 +1136,22 @@ 
         return $url;
     }
 
-   /**
-    * Calculates a percentage match of the source string with the target string.
-    * 
-    * Options are:
-    * 
-    * - maxLevenshtein, default: 10
-    *   Any levenshtein results above this value are ignored.
-    *   
-    * - precision, default: 1
-    *   The precision of the percentage float value
-    * 
-    * @param string $source
-    * @param string $target
-    * @param array $options
-    * @return float
-    */
+    /**
+     * Calculates a percentage match of the source string with the target string.
+     * 
+     * Options are:
+     * 
+     * - maxLevenshtein, default: 10
+     *   Any levenshtein results above this value are ignored.
+     *   
+     * - precision, default: 1
+     *   The precision of the percentage float value
+     * 
+     * @param string $source
+     * @param string $target
+     * @param array $options
+     * @return float
+     */
     public static function matchString($source, $target, $options=array())
     {
         $defaults = array(
@@ -1235,60 +1235,60 @@ 
     
     const INTERVAL_SECONDS = 'seconds';
     
-   /**
-    * Converts an interval to its total amount of days.
-    * @param \DateInterval $interval
-    * @return int
-    */
+    /**
+     * Converts an interval to its total amount of days.
+     * @param \DateInterval $interval
+     * @return int
+     */
     public static function interval2days(\DateInterval $interval) : int
     {
         return self::interval2total($interval, self::INTERVAL_DAYS);
     }
 
-   /**
-    * Converts an interval to its total amount of hours.
-    * @param \DateInterval $interval
-    * @return int
-    */
+    /**
+     * Converts an interval to its total amount of hours.
+     * @param \DateInterval $interval
+     * @return int
+     */
     public static function interval2hours(\DateInterval $interval) : int
     {
         return self::interval2total($interval, self::INTERVAL_HOURS);
     }
     
-   /**
-    * Converts an interval to its total amount of minutes. 
-    * @param \DateInterval $interval
-    * @return int
-    */
+    /**
+     * Converts an interval to its total amount of minutes. 
+     * @param \DateInterval $interval
+     * @return int
+     */
     public static function interval2minutes(\DateInterval $interval) : int
     {
         return self::interval2total($interval, self::INTERVAL_MINUTES);
     }
     
-   /**
-    * Converts an interval to its total amount of seconds.
-    * @param \DateInterval $interval
-    * @return int
-    */    
+    /**
+     * Converts an interval to its total amount of seconds.
+     * @param \DateInterval $interval
+     * @return int
+     */    
     public static function interval2seconds(\DateInterval $interval) : int
     {
         return self::interval2total($interval, self::INTERVAL_SECONDS);
     }
     
-   /**
-    * Calculates the total amount of days / hours / minutes or seconds
-    * of a date interval object (depending in the specified units), and 
-    * returns the total amount.
-    * 
-    * @param \DateInterval $interval
-    * @param string $unit What total value to calculate.
-    * @return integer
-    * 
-    * @see ConvertHelper::INTERVAL_SECONDS
-    * @see ConvertHelper::INTERVAL_MINUTES
-    * @see ConvertHelper::INTERVAL_HOURS
-    * @see ConvertHelper::INTERVAL_DAYS
-    */
+    /**
+     * Calculates the total amount of days / hours / minutes or seconds
+     * of a date interval object (depending in the specified units), and 
+     * returns the total amount.
+     * 
+     * @param \DateInterval $interval
+     * @param string $unit What total value to calculate.
+     * @return integer
+     * 
+     * @see ConvertHelper::INTERVAL_SECONDS
+     * @see ConvertHelper::INTERVAL_MINUTES
+     * @see ConvertHelper::INTERVAL_HOURS
+     * @see ConvertHelper::INTERVAL_DAYS
+     */
     public static function interval2total(\DateInterval $interval, $unit=self::INTERVAL_SECONDS) : int
     {
         $total = $interval->format('%a');
@@ -1328,13 +1328,13 @@ 
         'Sunday'
     );
     
-   /**
-    * Converts a date to the corresponding day name.
-    * 
-    * @param \DateTime $date
-    * @param string $short
-    * @return string|NULL
-    */
+    /**
+     * Converts a date to the corresponding day name.
+     * 
+     * @param \DateTime $date
+     * @param string $short
+     * @return string|NULL
+     */
     public static function date2dayName(\DateTime $date, $short=false)
     {
         $day = $date->format('l');
@@ -1349,21 +1349,21 @@ 
         return null;
     }
     
-   /**
-    * Retrieves a list of english day names.
-    * @return string[]
-    */
+    /**
+     * Retrieves a list of english day names.
+     * @return string[]
+     */
     public static function getDayNamesInvariant()
     {
         return self::$daysInvariant;
     }
     
-   /**
-    * Retrieves the day names list for the current locale.
-    * 
-    * @param string $short
-    * @return string[]
-    */
+    /**
+     * Retrieves the day names list for the current locale.
+     * 
+     * @param string $short
+     * @return string[]
+     */
     public static function getDayNames($short=false)
     {
         if($short) {
@@ -1423,16 +1423,16 @@ 
         return $last;
     }
     
-   /**
-    * Splits a string into an array of all characters it is composed of.
-    * Unicode character safe.
-    * 
-    * NOTE: Spaces and newlines (both \r and \n) are also considered single
-    * characters.
-    * 
-    * @param string $string
-    * @return array
-    */
+    /**
+     * Splits a string into an array of all characters it is composed of.
+     * Unicode character safe.
+     * 
+     * NOTE: Spaces and newlines (both \r and \n) are also considered single
+     * characters.
+     * 
+     * @param string $string
+     * @return array
+     */
     public static function string2array(string $string) : array
     {
         $result = preg_split('//u', $string, null, PREG_SPLIT_NO_EMPTY);
@@ -1443,12 +1443,12 @@ 
         return array();
     }
     
-   /**
-    * Checks whether the specified string contains HTML code.
-    * 
-    * @param string $string
-    * @return boolean
-    */
+    /**
+     * Checks whether the specified string contains HTML code.
+     * 
+     * @param string $string
+     * @return boolean
+     */
     public static function isStringHTML(string $string) : bool
     {
         if(preg_match('%<[a-z/][\s\S]*>%siU', $string)) {
@@ -1463,18 +1463,18 @@ 
         return false;
     }
     
-   /**
-    * UTF8-safe wordwrap method: works like the regular wordwrap
-    * PHP function but compatible with UTF8. Otherwise the lengths
-    * are no calculated correctly.
-    * 
-    * @param string $str
-    * @param int $width
-    * @param string $break
-    * @param bool $cut
-    * @return string
-    * @see https://stackoverflow.com/a/4988494/2298192
-    */
+    /**
+     * UTF8-safe wordwrap method: works like the regular wordwrap
+     * PHP function but compatible with UTF8. Otherwise the lengths
+     * are no calculated correctly.
+     * 
+     * @param string $str
+     * @param int $width
+     * @param string $break
+     * @param bool $cut
+     * @return string
+     * @see https://stackoverflow.com/a/4988494/2298192
+     */
     public static function wordwrap($str, $width = 75, $break = "\n", $cut = false) 
     {
         $lines = explode($break, $str);
@@ -1520,27 +1520,27 @@ 
         return implode($break, $lines);
     }
     
-   /**
-    * Calculates the byte length of a string, taking into 
-    * account any unicode characters.
-    * 
-    * @param string $string
-    * @return int
-    * @see https://stackoverflow.com/a/9718273/2298192
-    */
+    /**
+     * Calculates the byte length of a string, taking into 
+     * account any unicode characters.
+     * 
+     * @param string $string
+     * @return int
+     * @see https://stackoverflow.com/a/9718273/2298192
+     */
     public static function string2bytes($string)
     {
         return mb_strlen($string, '8bit');
     }
     
-   /**
-    * Creates a short, 8-character long hash for the specified string.
-    * 
-    * WARNING: Not cryptographically safe.
-    * 
-    * @param string $string
-    * @return string
-    */
+    /**
+     * Creates a short, 8-character long hash for the specified string.
+     * 
+     * WARNING: Not cryptographically safe.
+     * 
+     * @param string $string
+     * @return string
+     */
     public static function string2shortHash($string)
     {
         return hash('crc32', $string, false);
@@ -1566,23 +1566,23 @@ 
         return ConvertHelper_ThrowableInfo::fromThrowable($e);
     }
     
-   /**
-    * Parses the specified query string like the native 
-    * function <code>parse_str</code>, without the key
-    * naming limitations.
-    * 
-    * Using parse_str, dots or spaces in key names are 
-    * replaced by underscores. This method keeps all names
-    * intact.
-    * 
-    * It still uses the parse_str implementation as it 
-    * is tested and tried, but fixes the parameter names
-    * after parsing, as needed.
-    * 
-    * @param string $queryString
-    * @return array
-    * @see https://www.php.net/manual/en/function.parse-str.php
-    */
+    /**
+     * Parses the specified query string like the native 
+     * function <code>parse_str</code>, without the key
+     * naming limitations.
+     * 
+     * Using parse_str, dots or spaces in key names are 
+     * replaced by underscores. This method keeps all names
+     * intact.
+     * 
+     * It still uses the parse_str implementation as it 
+     * is tested and tried, but fixes the parameter names
+     * after parsing, as needed.
+     * 
+     * @param string $queryString
+     * @return array
+     * @see https://www.php.net/manual/en/function.parse-str.php
+     */
     public static function parseQueryString(string $queryString) : array
     {
         // allow HTML entities notation
@@ -1622,16 +1622,16 @@ 
             $placeholders = array();
             foreach($paramNames as $paramName)
             {
-                 // create a unique placeholder name
-                 $placeholder = '__PLACEHOLDER'.$counter.'__';
+                    // create a unique placeholder name
+                    $placeholder = '__PLACEHOLDER'.$counter.'__';
                  
-                 // store the placeholder name to replace later
-                 $table[$placeholder] = $paramName;
+                    // store the placeholder name to replace later
+                    $table[$placeholder] = $paramName;
                  
-                 // add the placeholder to replace in the query string before parsing
-                 $placeholders[$paramName.'='] = $placeholder.'=';
+                    // add the placeholder to replace in the query string before parsing
+                    $placeholders[$paramName.'='] = $placeholder.'=';
                  
-                 $counter++;
+                    $counter++;
             }
             
             // next challenge: replacing the parameter names by placeholders
@@ -1658,23 +1658,23 @@ 
         
         foreach($parsed as $name => $value)
         {
-             $keep[$table[$name]] = $value;
+                $keep[$table[$name]] = $value;
         }
         
         return $keep;
     }
 
-   /**
-    * Searches for needle in the specified string, and returns a list
-    * of all occurrences, including the matched string. The matched 
-    * string is useful when doing a case insensitive search, as it 
-    * shows the exact matched case of needle.
-    *   
-    * @param string $needle
-    * @param string $haystack
-    * @param bool $caseInsensitive
-    * @return ConvertHelper_StringMatch[]
-    */
+    /**
+     * Searches for needle in the specified string, and returns a list
+     * of all occurrences, including the matched string. The matched 
+     * string is useful when doing a case insensitive search, as it 
+     * shows the exact matched case of needle.
+     *   
+     * @param string $needle
+     * @param string $haystack
+     * @param bool $caseInsensitive
+     * @return ConvertHelper_StringMatch[]
+     */
     public static function findString(string $needle, string $haystack, bool $caseInsensitive=false)
     {
         if($needle === '') {
@@ -1700,14 +1700,14 @@ 
         return $positions;
     }
     
-   /**
-    * Like explode, but trims all entries, and removes 
-    * empty entries from the resulting array.
-    * 
-    * @param string $delimiter
-    * @param string $string
-    * @return string[]
-    */
+    /**
+     * Like explode, but trims all entries, and removes 
+     * empty entries from the resulting array.
+     * 
+     * @param string $delimiter
+     * @param string $string
+     * @return string[]
+     */
     public static function explodeTrim(string $delimiter, string $string) : array
     {
         if(empty($string) || empty($delimiter)) {
@@ -1729,12 +1729,12 @@ 
     
     protected static $eolChars;
 
-   /**
-    * Detects the most used end-of-line character in the subject string.
-    * 
-    * @param string $str The string to check.
-    * @return NULL|ConvertHelper_EOL The detected EOL instance, or NULL if none has been detected.
-    */
+    /**
+     * Detects the most used end-of-line character in the subject string.
+     * 
+     * @param string $str The string to check.
+     * @return NULL|ConvertHelper_EOL The detected EOL instance, or NULL if none has been detected.
+     */
     public static function detectEOLCharacter(string $subjectString) : ?ConvertHelper_EOL
     {
         if(empty($subjectString)) {
@@ -1746,27 +1746,27 @@ 
             $cr = chr((int)hexdec('0d'));
             $lf = chr((int)hexdec('0a'));
             
-           self::$eolChars = array(
-               array(
-                   'char' => $cr.$lf,
-                   'type' => ConvertHelper_EOL::TYPE_CRLF,
-                   'description' => t('Carriage return followed by a line feed'),
-               ),
-               array(
-                   'char' => $lf.$cr,
-                   'type' => ConvertHelper_EOL::TYPE_LFCR,
-                   'description' => t('Line feed followed by a carriage return'),
-               ),
-               array(
-                  'char' => $lf,
-                  'type' => ConvertHelper_EOL::TYPE_LF,
-                  'description' => t('Line feed'),
-               ),
-               array(
-                  'char' => $cr,
-                  'type' => ConvertHelper_EOL::TYPE_CR,
-                  'description' => t('Carriage Return'),
-               ),
+            self::$eolChars = array(
+                array(
+                    'char' => $cr.$lf,
+                    'type' => ConvertHelper_EOL::TYPE_CRLF,
+                    'description' => t('Carriage return followed by a line feed'),
+                ),
+                array(
+                    'char' => $lf.$cr,
+                    'type' => ConvertHelper_EOL::TYPE_LFCR,
+                    'description' => t('Line feed followed by a carriage return'),
+                ),
+                array(
+                    'char' => $lf,
+                    'type' => ConvertHelper_EOL::TYPE_LF,
+                    'description' => t('Line feed'),
+                ),
+                array(
+                    'char' => $cr,
+                    'type' => ConvertHelper_EOL::TYPE_CR,
+                    'description' => t('Carriage Return'),
+                ),
             );
         }
         
@@ -1794,13 +1794,13 @@ 
         );
     }
 
-   /**
-    * Removes the specified keys from the target array,
-    * if they exist.
-    * 
-    * @param array $array
-    * @param array $keys
-    */
+    /**
+     * Removes the specified keys from the target array,
+     * if they exist.
+     * 
+     * @param array $array
+     * @param array $keys
+     */
     public static function arrayRemoveKeys(array &$array, array $keys) : void
     {
         foreach($keys as $key) 
@@ -1811,13 +1811,13 @@ 
         }
     }
     
-   /**
-    * Checks if the specified variable is an integer or a string containing an integer.
-    * Accepts both positive and negative integers.
-    * 
-    * @param mixed $value
-    * @return bool
-    */
+    /**
+     * Checks if the specified variable is an integer or a string containing an integer.
+     * Accepts both positive and negative integers.
+     * 
+     * @param mixed $value
+     * @return bool
+     */
     public static function isInteger($value) : bool
     {
         if(is_int($value)) {
@@ -1837,15 +1837,15 @@ 
         return false;    
     }
     
-   /**
-    * Converts an amount of seconds to a DateInterval object.
-    * 
-    * @param int $seconds
-    * @return \DateInterval
-    * @throws ConvertHelper_Exception If the date interval cannot be created.
-    * 
-    * @see ConvertHelper::ERROR_CANNOT_GET_DATE_DIFF
-    */
+    /**
+     * Converts an amount of seconds to a DateInterval object.
+     * 
+     * @param int $seconds
+     * @return \DateInterval
+     * @throws ConvertHelper_Exception If the date interval cannot be created.
+     * 
+     * @see ConvertHelper::ERROR_CANNOT_GET_DATE_DIFF
+     */
     public static function seconds2interval(int $seconds) : \DateInterval
     {
         // The DateInterval::format() method does not recalculate carry 

Spacing +116 added lines, -116 removed lines

@@ -59,7 +59,7 @@ 
             $amount = substr_count($line, "\t") - $min;
             $line = trim($line);
             if ($amount >= 1) {
-                $line = str_repeat("\t", $amount) . $line;
+                $line = str_repeat("\t", $amount).$line;
             }
 
             $converted[] = $line;
@@ -131,10 +131,10 @@ 
 
         // specifically handle zero
         if ($seconds <= 0) {
-            return '0 ' . t('seconds');
+            return '0 '.t('seconds');
         }
         
-        if($seconds < 1) {
+        if ($seconds < 1) {
             return t('less than a second');
         }
 
@@ -142,7 +142,7 @@ 
         foreach ($units as $def) {
             $quot = intval($seconds / $def['value']);
             if ($quot) {
-                $item = $quot . ' ';
+                $item = $quot.' ';
                 if (abs($quot) > 1) {
                     $item .= $def['plural'];
                 } else {
@@ -159,7 +159,7 @@ 
             return $last;
         }
 
-        return implode(', ', $tokens) . ' ' . t('and') . ' ' . $last;
+        return implode(', ', $tokens).' '.t('and').' '.$last;
     }
 
     /**
@@ -176,11 +176,11 @@ 
      */
     public static function duration2string($datefrom, $dateto = -1)
     {
-        if($datefrom instanceof \DateTime) {
+        if ($datefrom instanceof \DateTime) {
             $datefrom = ConvertHelper::date2timestamp($datefrom);
         }
         
-        if($dateto instanceof \DateTime) {
+        if ($dateto instanceof \DateTime) {
             $dateto = ConvertHelper::date2timestamp($dateto);
         }
         
@@ -201,7 +201,7 @@ 
         $interval = "";
         
         $future = false;
-        if($difference < 0) {
+        if ($difference < 0) {
             $difference = $difference * -1;
             $future = true;
         }
@@ -276,7 +276,7 @@ 
                 $day = (int)date("j", $dateto);
                 $year = (int)date("Y", $datefrom);
                 
-                while(mktime($hour, $min, $sec, $month + ($months_difference), $day, $year) < $dateto) 
+                while (mktime($hour, $min, $sec, $month + ($months_difference), $day, $year) < $dateto) 
                 {
                     $months_difference++;
                 }
@@ -291,7 +291,7 @@ 
                     $datediff--;
                 }
 
-                if($future) {
+                if ($future) {
                     $result = ($datediff == 1) ? t('In one month', $datediff) : t('In %1s months', $datediff);
                 } else {
                     $result = ($datediff == 1) ? t('One month ago', $datediff) : t('%1s months ago', $datediff);
@@ -300,7 +300,7 @@ 
 
             case "y":
                 $datediff = floor($difference / 60 / 60 / 24 / 365);
-                if($future) {
+                if ($future) {
                     $result = ($datediff == 1) ? t('In one year', $datediff) : t('In %1s years', $datediff);
                 } else {
                     $result = ($datediff == 1) ? t('One year ago', $datediff) : t('%1s years ago', $datediff);
@@ -309,7 +309,7 @@ 
 
             case "d":
                 $datediff = floor($difference / 60 / 60 / 24);
-                if($future) {
+                if ($future) {
                     $result = ($datediff == 1) ? t('In one day', $datediff) : t('In %1s days', $datediff);
                 } else {
                     $result = ($datediff == 1) ? t('One day ago', $datediff) : t('%1s days ago', $datediff);
@@ -318,7 +318,7 @@ 
 
             case "ww":
                 $datediff = floor($difference / 60 / 60 / 24 / 7);
-                if($future) {
+                if ($future) {
                     $result = ($datediff == 1) ? t('In one week', $datediff) : t('In %1s weeks', $datediff);
                 } else {
                     $result = ($datediff == 1) ? t('One week ago', $datediff) : t('%1s weeks ago', $datediff);
@@ -327,7 +327,7 @@ 
 
             case "h":
                 $datediff = floor($difference / 60 / 60);
-                if($future) {
+                if ($future) {
                     $result = ($datediff == 1) ? t('In one hour', $datediff) : t('In %1s hours', $datediff);
                 } else {
                     $result = ($datediff == 1) ? t('One hour ago', $datediff) : t('%1s hours ago', $datediff);
@@ -336,7 +336,7 @@ 
 
             case "n":
                 $datediff = floor($difference / 60);
-                if($future) {
+                if ($future) {
                     $result = ($datediff == 1) ? t('In one minute', $datediff) : t('In %1s minutes', $datediff);
                 } else {
                     $result = ($datediff == 1) ? t('One minute ago', $datediff) : t('%1s minutes ago', $datediff);
@@ -345,7 +345,7 @@ 
 
             case "s":
                 $datediff = $difference;
-                if($future) {
+                if ($future) {
                     $result = ($datediff == 1) ? t('In one second', $datediff) : t('In %1s seconds', $datediff);
                 } else {
                     $result = ($datediff == 1) ? t('One second ago', $datediff) : t('%1s seconds ago', $datediff);
@@ -368,9 +368,9 @@ 
         return $geshi->parse_code();
     }
     
-    public static function highlight_xml($xml, $formatSource=false)
+    public static function highlight_xml($xml, $formatSource = false)
     {
-        if($formatSource) 
+        if ($formatSource) 
         {
             $dom = new \DOMDocument();
             $dom->loadXML($xml);
@@ -408,22 +408,22 @@ 
         $terabyte = $gigabyte * 1024;
 
         if (($bytes >= 0) && ($bytes < $kilobyte)) {
-            return $bytes . ' ' . t('B');
+            return $bytes.' '.t('B');
 
         } elseif (($bytes >= $kilobyte) && ($bytes < $megabyte)) {
-            return round($bytes / $kilobyte, $precision) . ' ' . t('Kb');
+            return round($bytes / $kilobyte, $precision).' '.t('Kb');
 
         } elseif (($bytes >= $megabyte) && ($bytes < $gigabyte)) {
-            return round($bytes / $megabyte, $precision) . ' ' . t('Mb');
+            return round($bytes / $megabyte, $precision).' '.t('Mb');
 
         } elseif (($bytes >= $gigabyte) && ($bytes < $terabyte)) {
-            return round($bytes / $gigabyte, $precision) . ' ' . t('Gb');
+            return round($bytes / $gigabyte, $precision).' '.t('Gb');
 
         } elseif ($bytes >= $terabyte) {
-            return round($bytes / $gigabyte, $precision) . ' ' . t('Tb');
+            return round($bytes / $gigabyte, $precision).' '.t('Tb');
         }
 
-        return $bytes . ' ' . t('B');
+        return $bytes.' '.t('B');
     }
 
    /**
@@ -443,34 +443,34 @@ 
             return $text;
         }
 
-        $text = trim(mb_substr($text, 0, $targetLength)) . $append;
+        $text = trim(mb_substr($text, 0, $targetLength)).$append;
 
         return $text;
     }
 
-    public static function var_dump($var, $html=true)
+    public static function var_dump($var, $html = true)
     {
         $info = parseVariable($var);
         
-        if($html) {
+        if ($html) {
             return $info->toHTML();
         }
         
         return $info->toString();
     }
     
-    public static function print_r($var, $return=false, $html=true)
+    public static function print_r($var, $return = false, $html = true)
     {
         $result = self::var_dump($var, $html);
         
-        if($html) {
+        if ($html) {
             $result = 
             '<pre style="background:#fff;color:#333;padding:16px;border:solid 1px #bbb;border-radius:4px">'.
                 $result.
             '</pre>';
         }
         
-        if($return) {
+        if ($return) {
             return $result;
         }
         
@@ -490,7 +490,7 @@ 
 
     public static function string2bool($string)
     {
-        if($string === '' || $string === null) {
+        if ($string === '' || $string === null) {
             return false;
         }
         
@@ -545,10 +545,10 @@ 
     public static function date2listLabel(\DateTime $date, $includeTime = false, $shortMonth = false)
     {
         $today = new \DateTime();
-        if($date->format('d.m.Y') == $today->format('d.m.Y')) {
+        if ($date->format('d.m.Y') == $today->format('d.m.Y')) {
             $label = t('Today');
         } else {
-            $label = $date->format('d') . '. ' . self::month2string((int)$date->format('m'), $shortMonth) . ' ';
+            $label = $date->format('d').'. '.self::month2string((int)$date->format('m'), $shortMonth).' ';
             if ($date->format('Y') != date('Y')) {
                 $label .= $date->format('Y');
             }
@@ -639,28 +639,28 @@ 
         $hexAlphabet = array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F');
         
         $stack = array();
-        foreach(self::$controlChars as $char)
+        foreach (self::$controlChars as $char)
         {
             $tokens = explode('-', $char);
             $start = $tokens[0];
             $end = $tokens[1];
             $prefix = substr($start, 0, 3);
             $range = array();
-            foreach($hexAlphabet as $number) {
+            foreach ($hexAlphabet as $number) {
                 $range[] = $prefix.$number;
             }
             
             $use = false;
-            foreach($range as $number) {
-                if($number == $start) {
+            foreach ($range as $number) {
+                if ($number == $start) {
                     $use = true;
                 }
                 
-                if($use) {
+                if ($use) {
                     $stack[] = $number;
                 }
                 
-                if($number == $end) {
+                if ($number == $end) {
                     break;
                 }
             }
@@ -681,7 +681,7 @@ 
         $chars = self::getControlCharactersAsHex();
         
         $result = array();
-        foreach($chars as $char) {
+        foreach ($chars as $char) {
             $result[] = hex2bin($char);
         }
         
@@ -699,14 +699,14 @@ 
         $chars = self::getControlCharactersAsHex();
         
         $result = array();
-        foreach($chars as $char) {
+        foreach ($chars as $char) {
             $result[] = '\u'.strtolower($char);
         }
         
         return $result;
     }
     
-    protected static $controlChars =  array(
+    protected static $controlChars = array(
         '0000-0008', // control chars
         '000E-000F', // control chars
         '0010-001F', // control chars
@@ -728,19 +728,19 @@ 
      */
     public static function stripControlCharacters(string $string) : string
     {
-        if(empty($string)) {
+        if (empty($string)) {
             return $string;
         }
         
         // create the regex from the unicode characters list
-        if(!isset(self::$controlCharsRegex)) 
+        if (!isset(self::$controlCharsRegex)) 
         {
             $chars = self::getControlCharactersAsHex();
 
             // we use the notation \x{0000} to specify the unicode character key
             // in the regular expression.
             $stack = array();
-            foreach($chars as $char) {
+            foreach ($chars as $char) {
                 $stack[] = '\x{'.$char.'}';
             }
             
@@ -774,7 +774,7 @@ 
             $ordInt = ord($octet);
             // Convert from int (base 10) to hex (base 16), for PHP \x syntax
             $ordHex = base_convert($ordInt, 10, 16);
-            $output .= '\x' . $ordHex;
+            $output .= '\x'.$ordHex;
         }
         return $output;
     }
@@ -806,19 +806,19 @@ 
     
     protected static function convertScalarForComparison($scalar)
     {
-        if($scalar === '' || is_null($scalar)) {
+        if ($scalar === '' || is_null($scalar)) {
             return null;
         }
         
-        if(is_bool($scalar)) {
+        if (is_bool($scalar)) {
             return self::bool2string($scalar);
         }
         
-        if(is_array($scalar)) {
+        if (is_array($scalar)) {
             $scalar = md5(serialize($scalar));
         }
         
-        if($scalar !== null && !is_scalar($scalar)) {
+        if ($scalar !== null && !is_scalar($scalar)) {
             throw new ConvertHelper_Exception(
                 'Not a scalar value in comparison',
                 null,
@@ -867,7 +867,7 @@ 
     public static function bool2string($boolean, bool $yesno = false) : string
     {
         // allow 'yes', 'true', 'no', 'false' string notations as well
-        if(!is_bool($boolean)) {
+        if (!is_bool($boolean)) {
             $boolean = self::string2bool($boolean);
         }
         
@@ -908,15 +908,15 @@ 
     public static function array2attributeString($array)
     {
         $tokens = array();
-        foreach($array as $attr => $value) {
-            if($value == '' || $value == null) {
+        foreach ($array as $attr => $value) {
+            if ($value == '' || $value == null) {
                 continue;
             }
             
             $tokens[] = $attr.'="'.$value.'"';
         }
         
-        if(empty($tokens)) {
+        if (empty($tokens)) {
             return '';
         }
         
@@ -931,10 +931,10 @@ 
     * @param string $string
     * @return string
     */
-    public static function string2attributeJS($string, $quoted=true)
+    public static function string2attributeJS($string, $quoted = true)
     {
         $converted = addslashes(htmlspecialchars(strip_tags($string), ENT_QUOTES, 'UTF-8'));
-        if($quoted) {
+        if ($quoted) {
             $converted = "'".$converted."'";
         } 
         
@@ -952,11 +952,11 @@ 
     */
     public static function isBoolean($value) : bool
     {
-        if(is_bool($value)) {
+        if (is_bool($value)) {
             return true;
         }
         
-        if(!is_scalar($value)) {
+        if (!is_scalar($value)) {
             return false;
         }
         
@@ -972,7 +972,7 @@ 
     public static function array2styleString(array $subject) : string
     {
         $tokens = array();
-        foreach($subject as $name => $value) {
+        foreach ($subject as $name => $value) {
             $tokens[] = $name.':'.$value;
         }
         
@@ -1030,7 +1030,7 @@ 
     * 
     * @see JSHelper::buildRegexStatement()
     */
-    public static function regex2js(string $regex, string $statementType=JSHelper::JS_REGEX_OBJECT)
+    public static function regex2js(string $regex, string $statementType = JSHelper::JS_REGEX_OBJECT)
     {
         return JSHelper::buildRegexStatement($regex, $statementType);
     }
@@ -1047,11 +1047,11 @@ 
     * @throws ConvertHelper_Exception
     * @return string
     */
-    public static function var2json($variable, int $options=0, int $depth=512) : string
+    public static function var2json($variable, int $options = 0, int $depth = 512) : string
     {
         $result = json_encode($variable, $options, $depth);
         
-        if($result !== false) {
+        if ($result !== false) {
             return $result;
         }
         
@@ -1076,10 +1076,10 @@ 
     public static function stripUTFBom($string)
     {
         $boms = FileHelper::getUTFBOMs();
-        foreach($boms as $bomChars) {
+        foreach ($boms as $bomChars) {
             $length = mb_strlen($bomChars);
             $text = mb_substr($string, 0, $length);
-            if($text==$bomChars) {
+            if ($text == $bomChars) {
                 return mb_substr($string, $length);
             }
         }
@@ -1096,7 +1096,7 @@ 
     */
     public static function string2utf8($string)
     {
-        if(!self::isStringASCII($string)) {
+        if (!self::isStringASCII($string)) {
             return \ForceUTF8\Encoding::toUTF8($string);
         }
         
@@ -1114,11 +1114,11 @@ 
     */
     public static function isStringASCII($string)
     {
-        if($string === '' || $string === NULL) {
+        if ($string === '' || $string === NULL) {
             return true;
         }
         
-        if(!is_string($string)) {
+        if (!is_string($string)) {
             return false;
         }
         
@@ -1152,7 +1152,7 @@ 
     * @param array $options
     * @return float
     */
-    public static function matchString($source, $target, $options=array())
+    public static function matchString($source, $target, $options = array())
     {
         $defaults = array(
             'maxLevenshtein' => 10,
@@ -1162,12 +1162,12 @@ 
         $options = array_merge($defaults, $options);
         
         // avoid doing this via levenshtein
-        if($source == $target) {
+        if ($source == $target) {
             return 100;
         }
         
         $diff = levenshtein($source, $target);
-        if($diff > $options['maxLevenshtein']) {
+        if ($diff > $options['maxLevenshtein']) {
             return 0;
         }
         
@@ -1181,8 +1181,8 @@ 
         
         $offset = 0;
         $keep = array();
-        foreach($tokens as $token) {
-            if($interval->$token > 0) {
+        foreach ($tokens as $token) {
+            if ($interval->$token > 0) {
                 $keep = array_slice($tokens, $offset);
                 break;
             }
@@ -1191,16 +1191,16 @@ 
         }
         
         $parts = array();
-        foreach($keep as $token) 
+        foreach ($keep as $token) 
         {
             $value = $interval->$token;
             $label = '';
             
             $suffix = 'p';
-            if($value == 1) { $suffix = 's'; }
+            if ($value == 1) { $suffix = 's'; }
             $token .= $suffix;
             
-            switch($token) {
+            switch ($token) {
                 case 'ys': $label = t('1 year'); break;
                 case 'yp': $label = t('%1$s years', $value); break;
                 case 'ms': $label = t('1 month'); break;
@@ -1218,7 +1218,7 @@ 
             $parts[] = $label;
         }
         
-        if(count($parts) == 1) {
+        if (count($parts) == 1) {
             return $parts[0];
         } 
         
@@ -1289,24 +1289,24 @@ 
     * @see ConvertHelper::INTERVAL_HOURS
     * @see ConvertHelper::INTERVAL_DAYS
     */
-    public static function interval2total(\DateInterval $interval, $unit=self::INTERVAL_SECONDS) : int
+    public static function interval2total(\DateInterval $interval, $unit = self::INTERVAL_SECONDS) : int
     {
         $total = $interval->format('%a');
         if ($unit == self::INTERVAL_DAYS) {
             return (int)$total;
         }
         
-        $total = ($total * 24) + ($interval->h );
+        $total = ($total * 24) + ($interval->h);
         if ($unit == self::INTERVAL_HOURS) {
             return (int)$total;
         }
     
-        $total = ($total * 60) + ($interval->i );
+        $total = ($total * 60) + ($interval->i);
         if ($unit == self::INTERVAL_MINUTES) {
             return (int)$total;
         }
 
-        $total = ($total * 60) + ($interval->s );
+        $total = ($total * 60) + ($interval->s);
         if ($unit == self::INTERVAL_SECONDS) {
             return (int)$total;
         }
@@ -1335,13 +1335,13 @@ 
     * @param string $short
     * @return string|NULL
     */
-    public static function date2dayName(\DateTime $date, $short=false)
+    public static function date2dayName(\DateTime $date, $short = false)
     {
         $day = $date->format('l');
         $invariant = self::getDayNamesInvariant();
         
         $idx = array_search($day, $invariant);
-        if($idx !== false) {
+        if ($idx !== false) {
             $localized = self::getDayNames($short);
             return $localized[$idx];
         }
@@ -1364,10 +1364,10 @@ 
     * @param string $short
     * @return string[]
     */
-    public static function getDayNames($short=false)
+    public static function getDayNames($short = false)
     {
-        if($short) {
-            if(!isset(self::$daysShort)) {
+        if ($short) {
+            if (!isset(self::$daysShort)) {
                 self::$daysShort = array(
                     t('Mon'),
                     t('Tue'),
@@ -1382,7 +1382,7 @@ 
             return self::$daysShort;
         }
         
-        if(!isset(self::$days)) {
+        if (!isset(self::$days)) {
             self::$days = array(
                 t('Monday'),
                 t('Tuesday'),
@@ -1407,17 +1407,17 @@ 
      */
     public static function implodeWithAnd(array $list, $sep = ', ', $conjunction = null)
     {
-        if(empty($list)) {
+        if (empty($list)) {
             return '';
         }
         
-        if(empty($conjunction)) {
+        if (empty($conjunction)) {
             $conjunction = t('and');
         }
         
         $last = array_pop($list);
-        if($list) {
-            return implode($sep, $list) . $conjunction . ' ' . $last;
+        if ($list) {
+            return implode($sep, $list).$conjunction.' '.$last;
         }
         
         return $last;
@@ -1436,7 +1436,7 @@ 
     public static function string2array(string $string) : array
     {
         $result = preg_split('//u', $string, null, PREG_SPLIT_NO_EMPTY);
-        if($result !== false) {
+        if ($result !== false) {
             return $result;
         }
         
@@ -1451,12 +1451,12 @@ 
     */
     public static function isStringHTML(string $string) : bool
     {
-        if(preg_match('%<[a-z/][\s\S]*>%siU', $string)) {
+        if (preg_match('%<[a-z/][\s\S]*>%siU', $string)) {
             return true;
         }
         
         $decoded = html_entity_decode($string);
-        if($decoded !== $string) {
+        if ($decoded !== $string) {
             return true;
         }
         
@@ -1593,7 +1593,7 @@ 
         // extract parameter names from the query string
         $result = array();
         preg_match_all('/&?([^&]+)=.*/sixU', $queryString, $result, PREG_PATTERN_ORDER);
-        if(isset($result[1])) {
+        if (isset($result[1])) {
             $paramNames = $result[1];
         }
         
@@ -1616,11 +1616,11 @@ 
         // possible naming conflicts like having both parameters "foo.bar" 
         // and "foo_bar" in the query string: since "foo.bar" would be converted
         // to "foo_bar", one of the two would be replaced.
-        if($fixRequired) 
+        if ($fixRequired) 
         {
             $counter = 1;
             $placeholders = array();
-            foreach($paramNames as $paramName)
+            foreach ($paramNames as $paramName)
             {
                  // create a unique placeholder name
                  $placeholder = '__PLACEHOLDER'.$counter.'__';
@@ -1650,13 +1650,13 @@ 
         parse_str($queryString, $parsed);
         
         // do any of the parameter names need to be fixed?
-        if(!$fixRequired) {
+        if (!$fixRequired) {
             return $parsed;
         }
         
         $keep = array();
         
-        foreach($parsed as $name => $value)
+        foreach ($parsed as $name => $value)
         {
              $keep[$table[$name]] = $value;
         }
@@ -1675,14 +1675,14 @@ 
     * @param bool $caseInsensitive
     * @return ConvertHelper_StringMatch[]
     */
-    public static function findString(string $needle, string $haystack, bool $caseInsensitive=false)
+    public static function findString(string $needle, string $haystack, bool $caseInsensitive = false)
     {
-        if($needle === '') {
+        if ($needle === '') {
             return array();
         }
         
         $function = 'mb_strpos';
-        if($caseInsensitive) {
+        if ($caseInsensitive) {
             $function = 'mb_stripos';
         }
         
@@ -1690,7 +1690,7 @@ 
         $positions = array();
         $length = mb_strlen($needle);
         
-        while( ($pos = $function($haystack, $needle, $pos)) !== false) 
+        while (($pos = $function($haystack, $needle, $pos)) !== false) 
         {
             $match = mb_substr($haystack, $pos, $length);
             $positions[] = new ConvertHelper_StringMatch($pos, $match);
@@ -1710,7 +1710,7 @@ 
     */
     public static function explodeTrim(string $delimiter, string $string) : array
     {
-        if(empty($string) || empty($delimiter)) {
+        if (empty($string) || empty($delimiter)) {
             return array();
         }
         
@@ -1718,8 +1718,8 @@ 
         $tokens = array_map('trim', $tokens);
         
         $keep = array();
-        foreach($tokens as $token) {
-            if($token !== '') {
+        foreach ($tokens as $token) {
+            if ($token !== '') {
                 $keep[] = $token;
             }
         }
@@ -1737,11 +1737,11 @@ 
     */
     public static function detectEOLCharacter(string $subjectString) : ?ConvertHelper_EOL
     {
-        if(empty($subjectString)) {
+        if (empty($subjectString)) {
             return null;
         }
         
-        if(!isset(self::$eolChars))
+        if (!isset(self::$eolChars))
         {
             $cr = chr((int)hexdec('0d'));
             $lf = chr((int)hexdec('0a'));
@@ -1772,18 +1772,18 @@ 
         
         $max = 0;
         $results = array();
-        foreach(self::$eolChars as $def) 
+        foreach (self::$eolChars as $def) 
         {
             $amount = substr_count($subjectString, $def['char']);
             
-            if($amount > $max)
+            if ($amount > $max)
             {
                 $max = $amount;
                 $results[] = $def;
             }
         }
         
-        if(empty($results)) {
+        if (empty($results)) {
             return null;
         }
         
@@ -1803,9 +1803,9 @@ 
     */
     public static function arrayRemoveKeys(array &$array, array $keys) : void
     {
-        foreach($keys as $key) 
+        foreach ($keys as $key) 
         {
-            if(array_key_exists($key, $array)) {
+            if (array_key_exists($key, $array)) {
                 unset($array[$key]); 
             }
         }
@@ -1820,17 +1820,17 @@ 
     */
     public static function isInteger($value) : bool
     {
-        if(is_int($value)) {
+        if (is_int($value)) {
             return true;
         }
         
         // booleans get converted to numbers, so they would
         // actually match the regex.
-        if(is_bool($value)) {
+        if (is_bool($value)) {
             return false;
         }
         
-        if(is_string($value) && $value !== '') {
+        if (is_string($value) && $value !== '') {
             return preg_match('/\A-?\d+\z/', $value) === 1;
         }
         
@@ -1857,7 +1857,7 @@ 
         $d2->add(new \DateInterval('PT'.$seconds.'S'));
         
         $result = $d2->diff($d1);
-        if($result !== false) {
+        if ($result !== false) {
             return $result;
         }