WebservicesNl\Utils\StringUtils

Complexity

Total Complexity

19

Size/Duplication

Total Lines	161
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getFileExtension()	0	9	3
A	stringEndsWith()	0	8	3
A	stringStartsWith()	0	8	3
A	removePrefix()	0	12	4
A	toCamelCase()	0	15	3
A	wordToUnderscored()	0	17	1
A	toUnderscore()	0	12	2

<?php

namespace WebservicesNl\Utils;

use Ddeboer\Transcoder\Transcoder;

/**
 * Class StringUtils.
 */
class StringUtils
{
    /**
     * @param string $filename
     * @param bool   $lowercase
     *
     * @throws \InvalidArgumentException
     *
     * @return string
     */
    public static function getFileExtension($filename, $lowercase = true)
    {
        if (false === is_string($filename)) {
            throw new \InvalidArgumentException(sprintf('Filename must be a string, %s given', gettype($filename)));
        }
        $extension = pathinfo($filename, PATHINFO_EXTENSION);

        return $lowercase ? strtolower($extension) : $extension;
    }

    /**
     * Determine if a string ends with a particular sequence.
     *
     * @param string $haystack
     * @param string $needle
     *
     * @throws \InvalidArgumentException
     *
     * @return bool
     */
    public static function stringEndsWith($haystack, $needle)
    {
        if (!is_string($haystack) || !is_string($needle)) {
            throw new \InvalidArgumentException('Not a string');
        }

        return (strrpos($haystack, $needle) + strlen($needle)) === strlen($haystack);
    }

    /**
     * Determine if a string starts with a particular sequence.
     *
     * @param string $haystack
     * @param string $needle
     *
     * @throws \InvalidArgumentException
     *
     * @return bool
     */
    public static function stringStartsWith($haystack, $needle)
    {
        if (!is_string($haystack) || !is_string($needle)) {
            throw new \InvalidArgumentException('Not a string');
        }

        return strpos($haystack, $needle) === 0;
    }

    /**
     * Remove the prefix from the provided string.
     *
     * @param string $haystack
     * @param string $prefix
     *
     * @throws \InvalidArgumentException
     *
     * @return string
     */
    public static function removePrefix($haystack, $prefix)
    {
        if (!is_string($haystack) || !is_string($prefix)) {
            throw new \InvalidArgumentException('Not a string');
        }

        if (strpos($haystack, $prefix) === 0) {
            $haystack = substr($haystack, strlen($prefix));
        }

        return $haystack;
    }

    /**
     * Convert strings with underscores into CamelCase (for getters and setters).
     *
     * @param string $string        The string to convert
     * @param bool   $firstCharCaps camelCase or CamelCase
     *
     * @throws \Ddeboer\Transcoder\Exception\UnsupportedEncodingException
     * @throws \Ddeboer\Transcoder\Exception\ExtensionMissingException
     * @throws \InvalidArgumentException
     *
     * @return string The converted string
     */
    public static function toCamelCase($string, $firstCharCaps = true)
    {
        if (!is_string($string)) {
            throw new \InvalidArgumentException('Not a string');
        }

        $transcoder = Transcoder::create();
        $string = $transcoder->transcode($string);

        if ($firstCharCaps === true) {
            $string = ucfirst($string);
        }

        return $string;
    }

    /**
     * Internal function for toUnderscore.
     *
     * @param string $word
     *
     * @throws \InvalidArgumentException
     *
     * @return string
     */
    private static function wordToUnderscored($word)

This method is not used, and could be removed.

    {
        return strtolower(
            trim(
                preg_replace(
                    '~[^a-z^\d]+~i',
                    '_',
                    preg_replace(
                        '~([a-z\d+])([A-Z])~',
                        '\1_\2',
                        preg_replace('~([A-Z]+)([A-Z][a-z])~', '\1_\2', $word)
                    )
                ),
                '_'
            )
        );
    }

    /**
     * Converts a string to underscore version.
     * Also tries to filter out higher UTF-8 chars.
     *
     * @param string $string
     *
     * @throws \Ddeboer\Transcoder\Exception\UnsupportedEncodingException
     * @throws \Ddeboer\Transcoder\Exception\ExtensionMissingException
     * @throws \InvalidArgumentException
     *
     * @return string
     */
    public static function toUnderscore($string)
    {
        if (!is_string($string)) {
            throw new \InvalidArgumentException('Not a string');
        }

        $transCoder = Transcoder::create('ASCII');
        $string = $transCoder->transcode(trim($string));
        $words = explode(' ', $string);

        return implode('_', array_filter(array_map([static::class, 'wordToUnderscored'], $words)));
    }
}