String helper class

<?php

/**
 *
 * String helper class
 *
 */
abstract class Sheldon_Misc_String_Helper {
        
    /**
     * @param $sStr - String to clean
     *
     * @return string clean string
     *
     */
    static function cleanWhitespaces( $sStr ) {
        if ( ! empty( $sStr ) ) {
            return preg_replace('/\s+/', '', $sStr );
        }
        return $sStr;
    }


    /**
     * reverse function for nl2br
     *
     * @param $string - string with br's
     *
     * @return string - string with \n
     */
    static function br2nl( $string ) {
        return preg_replace( '/\<br(\s*)?\/?\>/i', "\n", $string );
    }

    /**
     * @param      $string - string with
     * @param bool $xhtml  - deliver xhtml confom br's or not (<br /> or <br>)
     *
     * @return mixed - string with br's
     */
    static function realNl2br( $string, $xhtml = true ) {
        $replace = '<br />';
        if ( ! $xhtml ) {
            $replace = '<br>';
        }

        return str_replace( "\n", $replace, $string );
    }

    /**
     * explodes a string to an array. Then all values are trimed and lowered
     *
     * @param $string
     * @param $delimiter
     *
     * @return array
     */
    static function trimToLowerExplode( $string, $delimiter = ',' ) {
        return array_map(
            'strtolower',
            array_map( 'trim',
                explode( $delimiter, $string )
            )
        );
    }

    /**
     * explodes a string to an array. Then all values are trimed and made
     * uppercase
     *
     * @param $string
     * @param $delimiter
     *
     * @return array
     */
    static function trimToUpperExplode( $string, $delimiter = ',' ) {
        return array_map(
            'strtoupper',
            array_map( 'trim',
                explode( $delimiter, $string )
            )
        );
    }

    /**
     * explodes a string to an array. Then all values are trimed
     *
     * @param $string
     * @param $delimiter
     *
     * @return array
     */
    static function trimExplode( $string, $delimiter = ',' ) {
        return array_map( 'trim',
            explode( $delimiter, $string )
        );
    }

    /**
     * Implodes an array to a string. All values are trimed before
     *
     * @param array  $aArray
     * @param string $sGlue
     *
     * @return string
     */
    static function trimImplode( array $aArray, $sGlue = ',' ) {
        return implode( $sGlue, array_map( 'trim', $aArray ) );
    }

    /**
     * Checks if the string $haystack ends with needle
     *
     * @param $haystack
     * @param $needle
     *
     * @return bool
     */
    static function endsWith( $haystack, $needle ) {
        return ( strrpos( $haystack, $needle ) === strlen( $haystack )
                                                   - strlen( $needle ) );
    }

    /**
     * Checks if the string $haystack ends with needle
     *
     * @param $haystack
     * @param $needle
     *
     * @return bool
     */
    static function startsWith( $haystack, $needle ) {
        return ( strpos( $haystack, $needle ) === 0 );
    }

    /**
     * Crops the text at a useful position before/after the given amount of
     * characters and adds "...".
     *
     * @return string - croped text
     *
     * @param string $origText - original text
     * @param int    $maxchars - target length (aprox.)
     */
    static function cropTextNice( $origText, $maxchars ) {
        //Länge der Originaltextes feststellen
        $origLength = strlen( $origText );

        //Wenn der Nachrichtentext weniger Zeichen enthält als die gewünschte Maximallänge,
        //wird der der Originaltext zurückgegeben.
        if ( $maxchars >= $origLength ) {
            return $origText;
        }

        //Abschneiden des Textes nach der gewünschten Zeichenanzahl:
        $text = substr( $origText, 0, $maxchars );

        //letztes Zeichen der beschnittenen Zeichenkette bestimmen
        $lastChar = substr( $text, - 1, 1 );

        $isEnd = false;

        // Solange das letzte Zeichen kein Lehrzeichen ist,
        // wird immer ein weiteres Zeichen aus dem abgeschnittenen Textteil hinzugefügt
        // um eine Trennung innerhalb eines Wortes zu verhindern.
        while ( $lastChar != ' ' ) {
            //Wenn das Ende des Nachrichtentextes erreicht wurde kann abgebrochen werden.
            if ( $maxchars == $origLength ) {
                $isEnd = true;
                break;
            }

            //weiteres Zeichen aus Originaltext anhängen
            $text = substr( $text, 0, $maxchars -- );

            //neues letztes Zeichen bestimmen
            $lastChar = substr( $text, - 1, 1 );
        }


        // Wenn der text abgeschnitten wurden, werden drei Punkte angehangen,
        // um zu kennzeichnen, dass die NAchricht unvollständig dargestellt wird.
        if ( ! $isEnd ) {
            $text .= '...';
        }

        return $text;
    }

    /**
     * Parses an textarea input value and returns a multidimensional array that
     * contains all rows as sub arrays. The entries are separated via ";". The
     * first part becomes the array key. The following entries itselve can be
     * seperated again with "," wich results in a sub-sub-array
     *
     * @excample:
     * $text="
     *   channel1; value, valueb,; test1, test2, test3 \n
     *   channel2; value1; tester1, tester2, tester3; \n
     *   channel3; value2
     *  ";
     * echo "<pre>";
     * print_r(self::getTextareaMapping($text, array('roots', 'strores'),
     * array('a','b', 'c'))); echo "</pre>";
     *
     * Result:
     * Array(
     *      [channel1] => Array(
     *          [roots] => Array(
     *              [a] => value
     *              [b] => valueb
     *          )
     *          [strores] => Array(
     *              [a] => test1
     *              [b] => test2
     *              [c] => test3
     *          )
     *      )
     *      [channel2] => Array(
     *          [roots] => value1
     *          [strores] => Array(
     *              [a] => tester1
     *              [b] => tester2
     *              [c] => tester3
     *          )
     *      )
     *      [channel3] => Array(
     *          [roots] => value2
     *      )
     * )
     *
     * @param $textareaContent - Content of an textarea inputfield with rows
     *                         separated with \n
     * @param $secondLevelKeys - keys for the second array level
     * @param $thirdLevelKeys  - keys for the third array level
     *
     * @return array - textarea per line and field and subfields
     */
    static function getTextareaMapping(
        $textareaContent, $secondLevelKeys = [], $thirdLevelKeys = []
    ) {
        $map       = [];
        $mapConfig = explode( "\n", $textareaContent );
        foreach ( $mapConfig as $row ) {
            $row = self::trimExplode( $row, ';' );

            //first part is the key
            if ( isset( $row[0] )
                 && ! empty( $row[0] )
            ) {
                $children = [];

                //deal with the rest of the row
                for ( $i = 1; $i < count( $row ); $i ++ ) {
                    if ( strpos( $row[ $i ], ',' ) ) {
                        $parts     = self::trimExplode( $row[ $i ], ',' );
                        $row[ $i ] = [];
                        for ( $j = 0; $j < count( $parts ); $j ++ ) {
                            if ( isset( $parts[ $j ] )
                                 && ! empty( $parts[ $j ] )
                            ) {
                                $key = $j;
                                if ( isset( $thirdLevelKeys[ $j ] ) ) {
                                    $key = $thirdLevelKeys[ $j ];
                                }
                                $row[ $i ][ $key ] = $parts[ $j ];
                            }
                        }
                    }
                    $key = $i;
                    if ( isset( $secondLevelKeys[ $i - 1 ] ) ) {
                        $key = $secondLevelKeys[ $i - 1 ];
                    }
                    if ( ! empty( $row[ $i ] ) ) {
                        $children[ $key ] = $row[ $i ];
                    }
                }
                $map[ $row[0] ] = $children;
            }
        }

        return $map;
    }
}

Leave a Reply

Your email address will not be published.

 

This site uses Akismet to reduce spam. Learn how your comment data is processed.