StringsMethods::toSnakeCase() - Code Metrics - mariosvasiliou/underscore_php - Measure and Improve Code Quality continuously with Scrutinizer

StringsMethods::toSnakeCase() A
last analyzed 2024-11-29 13:23 UTC

↳ Parent: StringsMethods
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes
Metric	Value
eloc	1
dl	0
loc	3
ccs	0
cts	0
cp	0
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	2
<?php
declare(strict_types=1);

/*
 * This file is part of Underscore.php
 *
 * (c) Maxime Fabre <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Underscore\Methods;

use Doctrine\Inflector\CachedWordInflector;
use Doctrine\Inflector\Inflector;
use Doctrine\Inflector\Rules\English\Rules;
use Doctrine\Inflector\RulesetInflector;
use Exception;
use RuntimeException;
use Underscore\Types\Strings;
use function Symfony\Component\String\u;

/**
 * Methods to manage strings.
 */
class StringsMethods
{

    /**
     * Uncountable word forms.
     */
    public static array $uncountable = [
        'audio',
        'bison',
        'cattle',
        'chassis',
        'compensation',
        'coreopsis',
        'data',
        'deer',
        'education',
        'emoji',
        'equipment',
        'evidence',
        'feedback',
        'firmware',
        'fish',
        'furniture',
        'gold',
        'hardware',
        'information',
        'jedi',
        'kin',
        'knowledge',
        'love',
        'metadata',
        'money',
        'moose',
        'news',
        'nutrition',
        'offspring',
        'plankton',
        'pokemon',
        'police',
        'rain',
        'recommended',
        'related',
        'rice',
        'series',
        'sheep',
        'software',
        'species',
        'swine',
        'traffic',
        'wheat',
    ];

    ////////////////////////////////////////////////////////////////////
    ////////////////////////////// CREATE  /////////////////////////////
    ////////////////////////////////////////////////////////////////////

    /**
     * Create a string from a number.
     *
     * @param  int  $count  A number
     * @param  string  $many  If many
     * @param  string  $one  If one
     * @param  string|null  $zero  If one
     *
     * @return string A string
     */
    public static function accord(int $count, string $many, string $one, string $zero = null) : string
    {
        if ($count === 1) {
            $output = $one;
        } elseif ($count === 0 && ! empty($zero)) {
            $output = $zero;
        } else {
            $output = $many;
        }

        return sprintf($output, $count);
    }

    /**
     * Generate a more truly "random" alpha-numeric string.
     *
     * @author Taylor Otwell
     *
     *
     */
    public static function random(int $length = 16) : string
    {
        if (\function_exists('random_bytes')) {
            try {
                $bytes = \random_bytes($length * 2);
            } catch (Exception) {
                throw new RuntimeException('Unable to generate random string.');
            }

            if ($bytes === '') {
                throw new RuntimeException('Unable to generate random string.');
            }

            return substr(str_replace(['/', '+', '='], '', base64_encode($bytes)), 0, $length);
        }

        return static::quickRandom($length);
    }

    /**
     * Generate a "random" alpha-numeric string.
     * Should not be considered sufficient for cryptography, etc.
     *
     * @author Taylor Otwell
     *
     *
     */
    public static function quickRandom(int $length = 16) : string
    {
        $pool = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

        return substr(str_shuffle(str_repeat($pool, $length)), 0, $length);
    }

    /**
     * Generates a random suite of words.
     *
     * @param  int  $words  The number of words
     * @param  int  $length  The length of each word
     */
    public static function randomStrings(int $words, int $length = 10) : string
    {
        return Strings::from('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')
                      ->shuffle()
                      ->/** @scrutinizer ignore-call */ shuffle()
                      ->split($length)
                      ->/** @scrutinizer ignore-call */ split($length)
                      ->slice(0, $words)
                      ->/** @scrutinizer ignore-call */ slice(0, $words)
                      ->implode(' ')
                      ->/** @scrutinizer ignore-call */ implode(' ')
                      ->obtain();
    }

    ////////////////////////////////////////////////////////////////////
    ////////////////////////////// ANALYZE /////////////////////////////
    ////////////////////////////////////////////////////////////////////
    /**
     * Determine if a given string ends with a given substring.
     *
     * @author Taylor Otwell
     *
     *
     */
    public static function endsWith(string $haystack, array|string $needles) : bool
    {
        foreach ((array) $needles as $needle) {
            if (str_ends_with($haystack, (string) $needle)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Check if a string is an IP.
     *
     * @param $string
     */
    public static function isIp($string) : bool
    {
        return filter_var($string, FILTER_VALIDATE_IP) !== false;
    }

    /**
     * Check if a string is an email.
     *
     * @param $string
     */
    public static function isEmail($string) : bool
    {
        return filter_var($string, FILTER_VALIDATE_EMAIL) !== false;
    }

    /**
     * Check if a string is an url.
     *
     * @param $string
     */
    public static function isUrl($string) : bool
    {
        return filter_var($string, FILTER_VALIDATE_URL) !== false;
    }

    /**
     * Determine if a given string starts with a given substring.
     *
     * @author Taylor Otwell
     *
     *
     */
    public static function startsWith(string $haystack, array|string $needles) : bool
    {
        foreach ((array) $needles as $needle) {
            if ($needle !== '' && str_starts_with($haystack, (string) $needle)) {
                return true;
            }
        }

        return false;
    }

    ////////////////////////////////////////////////////////////////////
    ///////////////////////////// FETCH FROM ///////////////////////////
    ////////////////////////////////////////////////////////////////////

    /**
     * Find one or more needles in one or more haystacks.
     *
     * @param  array|string  $string  The haystack(s) to search in
     * @param  array|string  $needle  The needle(s) to search for
     * @param  bool  $caseSensitive  Whether the function is case sensitive or not
     * @param  bool  $absolute  Whether all needle need to be found or whether one is enough
     *
     * @return bool Found or not
     */
    public static function find(
        array|string $string,
        array|string $needle,
        bool $caseSensitive = false,
        bool $absolute = false
    ) : bool
    {
        // If several needles
        if (\is_array($needle) || \is_array($string)) {

            $sliceFrom = $string;
            $sliceTo   = $needle;

            if (\is_array($needle)) {
                $sliceFrom = $needle;
                $sliceTo   = $string;
            }

            $found = 0;
            foreach ($sliceFrom as $need) {
                if (static::find($sliceTo, $need, $absolute, $caseSensitive)) {
                    ++$found;
                }
            }

            return ($absolute) ? \count($sliceFrom) === $found : $found > 0;
        }

        // If not case sensitive
        if (!$caseSensitive) {
            $string = strtolower($string);
            $needle = strtolower($needle);
        }

        // If string found
        $pos = strpos($string, $needle);

        return $pos !== false;
    }

    /**
     * Slice a string with another string.
     *
     * @param $string
     * @param $slice
     */
    public static function slice($string, $slice) : array
    {
        $sliceTo   = static::sliceTo($string, $slice);
        $sliceFrom = static::sliceFrom($string, $slice);

        return [$sliceTo, $sliceFrom];
    }

    /**
     * Slice a string from a certain point.
     *
     * @param $string
     * @param $slice
     *
     * @return false|string
     */
    public static function sliceFrom($string, $slice) : bool|string
    {
        $slice = strpos((string) $string, (string) $slice);

        return substr((string) $string, $slice);
    }

    /**
     * Slice a string up to a certain point.
     *
     * @param $string
     * @param $slice
     *
     * @return false|string
     */
    public static function sliceTo($string, $slice) : bool|string
    {
        $slice = strpos((string) $string, (string) $slice);

        return substr((string) $string, 0, $slice);
    }

    /**
     * Get the base class in a namespace.
     *
     *
     */
    public static function baseClass(string $string) : string
    {
        $path = static::replace($string, '\\', '/');

        return basename($path);
    }

    ////////////////////////////////////////////////////////////////////
    /////////////////////////////// ALTER //////////////////////////////
    ////////////////////////////////////////////////////////////////////
    /**
     * Prepend a string with another.
     *
     * @param  string  $string  The string
     * @param  string  $with  What to prepend with
     */
    public static function prepend(string $string, string $with) : string
    {
        return $with.$string;
    }

    /**
     * Append a string to another.
     *
     * @param  string  $string  The string
     * @param  string  $with  What to append with
     */
    public static function append(string $string, string $with) : string
    {
        return $string.$with;
    }

    /**
     * Limit the number of characters in a string.
     *
     * @author Taylor Otwell
     *
     *
     */
    public static function limit(string $value, int $limit = 100, string $end = '...') : string
    {
        if (mb_strlen($value) <= $limit) {
            return $value;
        }

        return rtrim(mb_substr($value, 0, $limit, 'UTF-8')).$end;
    }

    /**
     * Remove part of a string.
     *
     * @param $string
     * @param $remove
     */
    public static function remove($string, $remove) : string
    {
        if (\is_array($remove)) {
            $string = preg_replace('#('.implode('|', $remove).')#', '', (string) $string);
        }

        // Trim and return
        return trim(str_replace($remove, '', $string));
    }

    /**
     * Correct arguments order for str_replace.
     *
     * @param $string
     * @param $replace
     * @param $with
     *
     * @return string|string[]
     */
    public static function replace($string, $replace, $with) : array|string
    {
        return str_replace($replace, $with, $string);
    }

    /**
     * Toggles a string between two states.
     *
     * @param  string  $string  The string to toggle
     * @param  string  $first  First value
     * @param  string  $second  Second value
     * @param  bool  $loose  Whether a string neither matching 1 or 2 should be changed
     *
     * @return string The toggled string
     */
    public static function toggle(string $string, string $first, string $second, bool $loose = false) : string
    {
        // If the string given match none of the other two, and we're in strict mode, return it
        if ( ! $loose && ! \in_array($string, [$first, $second], true)) {
            return $string;
        }

        return $string === $first ? $second : $first;
    }

    /**
     * Generate a URL friendly "slug" from a given string.
     *
     * @author Taylor Otwell
     *
     *
     */
    protected static function slug(string $title, string $separator = '-') : string
    {
        $title = u($title)->ascii()->toString();
        // Convert all dashes/underscores into separator
        $flip = $separator === '-' ? '_' : '-';

        $title = preg_replace('!['.preg_quote($flip).']+!u', $separator, $title);

        // Remove all characters that are not the separator, letters, numbers, or whitespace.
        $title = preg_replace('![^'.preg_quote($separator).'\pL\pN\s]+!u', '', mb_strtolower((string) $title));

        // Replace all separator characters and whitespace by a single separator
        $title = preg_replace('!['.preg_quote($separator).'\s]+!u', $separator, (string) $title);

        return trim((string) $title, $separator);
    }

    /**
     * Slugifies a string.
     *
     * @param        $string
     *
     */
    public static function slugify($string, string $separator = '-') : string
    {
        $string = str_replace('_', ' ', $string);

        return static::slug($string, $separator);
    }

    /**
     * Explode a string into an array.
     *
     * @param      $string
     * @param      $with
     *
     */
    public static function explode($string, $with, $limit = null) : array
    {
        if ( ! $limit) {
            return explode($with, (string) $string);
        }

        return explode($with, (string) $string, $limit);
    }

    /**
     * Lowercase a string.
     *
     *
     */
    public static function lower(string $string) : string
    {
        return mb_strtolower($string, 'UTF-8');
    }

    /**
     * Get the plural form of an English word.
     *
     *
     * @return string
     */
    public static function plural(string $value = null) : ?string
    {
        if (static::uncountable($value)) {
        if (static::uncountable(/** @scrutinizer ignore-type */ $value)) {
            return $value;
        }

        $plural = static::inflector()->pluralize($value);
        $plural = static::inflector()->pluralize(/** @scrutinizer ignore-type */ $value);

        return static::matchCase($plural, $value);
        return static::matchCase($plural, /** @scrutinizer ignore-type */ $value);
    }

    /**
     * Get the singular form of an English word.
     *
     *
     */
    public static function singular(string $value) : string
    {
        $singular = static::inflector()->singularize($value);

        return static::matchCase($singular, $value);
    }

    /**
     * Lowercase a string.
     *
     *
     */
    public static function upper(string $string) : string
    {
        return mb_strtoupper($string, 'UTF-8');
    }

    /**
     * Convert a string to title case.
     *
     *
     */
    public static function title(string $string) : string
    {
        return mb_convert_case($string, MB_CASE_TITLE, 'UTF-8');
    }

    /**
     * Limit the number of words in a string.
     *
     * @author Taylor Otwell
     *
     *
     */
    public static function words(string $value, int $words = 100, string $end = '...') : string
    {
        preg_match('/^\s*+(?:\S++\s*+){1,'.$words.'}/u', $value, $matches);

        if ( ! \array_key_exists(0, $matches) || \strlen($value) === \strlen($matches[0])) {
            return $value;
        }

        return rtrim($matches[0]).$end;
    }

    ////////////////////////////////////////////////////////////////////
    /////////////////////////// CASE SWITCHERS /////////////////////////
    ////////////////////////////////////////////////////////////////////
    /**
     * Convert a string to PascalCase.
     *
     *
     */
    public static function toPascalCase(string $string) : string
    {
        return u($string)->camel()->title()->toString();
    }

    /**
     * Convert a string to snake_case.
     *
     *
     */
    public static function toSnakeCase(string $string) : string
    {
        return u($string)->snake()->toString();
    }

    /**
     * Convert a string to camelCase.
     *
     *
     */
    public static function toCamelCase(string $string) : string
    {
        return u($string)->camel()->toString();
    }

    /**
     * Get the inflector instance.
     */
    public static function inflector() : Inflector
    {
        static $inflector;

        if ($inflector === null) {
            $inflector = new Inflector(
                new CachedWordInflector(new RulesetInflector(
                    Rules::getSingularRuleset()
                )),
                new CachedWordInflector(new RulesetInflector(
                    Rules::getPluralRuleset()
                ))
            );
        }

        return $inflector;
    }

    /**
     * Determine if the given value is uncountable.
     *
     *
     */
    protected static function uncountable(string $value) : bool
    {
        return \in_array(strtolower($value), static::$uncountable, true);
    }

    /**
     * Attempt to match the case on two strings.
     *
     *
     */
    protected static function matchCase(string $value, string $comparison) : string
    {
        $functions = ['mb_strtolower', 'mb_strtoupper', 'ucfirst', 'ucwords'];

        foreach ($functions as $function) {
            if ($function($comparison) === $comparison) {
                return $function($value);
            }
        }

        return $value;
    }
}

mariosvasiliou / underscore_php

GitHub Access Token became invalid

StringsMethods::toSnakeCase() A last analyzed 2024-11-29 13:23 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

StringsMethods::toSnakeCase() A
last analyzed 2024-11-29 13:23 UTC
