1177 lines
26 KiB
PHP
1177 lines
26 KiB
PHP
<?php
|
|
|
|
use Illuminate\Support\Arr;
|
|
use Illuminate\Support\Str;
|
|
use Illuminate\Support\Optional;
|
|
use Illuminate\Support\Collection;
|
|
use Illuminate\Support\Debug\Dumper;
|
|
use Illuminate\Contracts\Support\Htmlable;
|
|
use Illuminate\Support\HigherOrderTapProxy;
|
|
|
|
if (! function_exists('append_config')) {
|
|
/**
|
|
* Assign high numeric IDs to a config item to force appending.
|
|
*
|
|
* @param array $array
|
|
* @return array
|
|
*/
|
|
function append_config(array $array)
|
|
{
|
|
$start = 9999;
|
|
|
|
foreach ($array as $key => $value) {
|
|
if (is_numeric($key)) {
|
|
$start++;
|
|
|
|
$array[$start] = Arr::pull($array, $key);
|
|
}
|
|
}
|
|
|
|
return $array;
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_add')) {
|
|
/**
|
|
* Add an element to an array using "dot" notation if it doesn't exist.
|
|
*
|
|
* @param array $array
|
|
* @param string $key
|
|
* @param mixed $value
|
|
* @return array
|
|
*/
|
|
function array_add($array, $key, $value)
|
|
{
|
|
return Arr::add($array, $key, $value);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_collapse')) {
|
|
/**
|
|
* Collapse an array of arrays into a single array.
|
|
*
|
|
* @param array $array
|
|
* @return array
|
|
*/
|
|
function array_collapse($array)
|
|
{
|
|
return Arr::collapse($array);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_divide')) {
|
|
/**
|
|
* Divide an array into two arrays. One with keys and the other with values.
|
|
*
|
|
* @param array $array
|
|
* @return array
|
|
*/
|
|
function array_divide($array)
|
|
{
|
|
return Arr::divide($array);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_dot')) {
|
|
/**
|
|
* Flatten a multi-dimensional associative array with dots.
|
|
*
|
|
* @param array $array
|
|
* @param string $prepend
|
|
* @return array
|
|
*/
|
|
function array_dot($array, $prepend = '')
|
|
{
|
|
return Arr::dot($array, $prepend);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_except')) {
|
|
/**
|
|
* Get all of the given array except for a specified array of keys.
|
|
*
|
|
* @param array $array
|
|
* @param array|string $keys
|
|
* @return array
|
|
*/
|
|
function array_except($array, $keys)
|
|
{
|
|
return Arr::except($array, $keys);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_first')) {
|
|
/**
|
|
* Return the first element in an array passing a given truth test.
|
|
*
|
|
* @param array $array
|
|
* @param callable|null $callback
|
|
* @param mixed $default
|
|
* @return mixed
|
|
*/
|
|
function array_first($array, callable $callback = null, $default = null)
|
|
{
|
|
return Arr::first($array, $callback, $default);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_flatten')) {
|
|
/**
|
|
* Flatten a multi-dimensional array into a single level.
|
|
*
|
|
* @param array $array
|
|
* @param int $depth
|
|
* @return array
|
|
*/
|
|
function array_flatten($array, $depth = INF)
|
|
{
|
|
return Arr::flatten($array, $depth);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_forget')) {
|
|
/**
|
|
* Remove one or many array items from a given array using "dot" notation.
|
|
*
|
|
* @param array $array
|
|
* @param array|string $keys
|
|
* @return void
|
|
*/
|
|
function array_forget(&$array, $keys)
|
|
{
|
|
return Arr::forget($array, $keys);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_get')) {
|
|
/**
|
|
* Get an item from an array using "dot" notation.
|
|
*
|
|
* @param \ArrayAccess|array $array
|
|
* @param string $key
|
|
* @param mixed $default
|
|
* @return mixed
|
|
*/
|
|
function array_get($array, $key, $default = null)
|
|
{
|
|
return Arr::get($array, $key, $default);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_has')) {
|
|
/**
|
|
* Check if an item or items exist in an array using "dot" notation.
|
|
*
|
|
* @param \ArrayAccess|array $array
|
|
* @param string|array $keys
|
|
* @return bool
|
|
*/
|
|
function array_has($array, $keys)
|
|
{
|
|
return Arr::has($array, $keys);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_last')) {
|
|
/**
|
|
* Return the last element in an array passing a given truth test.
|
|
*
|
|
* @param array $array
|
|
* @param callable|null $callback
|
|
* @param mixed $default
|
|
* @return mixed
|
|
*/
|
|
function array_last($array, callable $callback = null, $default = null)
|
|
{
|
|
return Arr::last($array, $callback, $default);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_only')) {
|
|
/**
|
|
* Get a subset of the items from the given array.
|
|
*
|
|
* @param array $array
|
|
* @param array|string $keys
|
|
* @return array
|
|
*/
|
|
function array_only($array, $keys)
|
|
{
|
|
return Arr::only($array, $keys);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_pluck')) {
|
|
/**
|
|
* Pluck an array of values from an array.
|
|
*
|
|
* @param array $array
|
|
* @param string|array $value
|
|
* @param string|array|null $key
|
|
* @return array
|
|
*/
|
|
function array_pluck($array, $value, $key = null)
|
|
{
|
|
return Arr::pluck($array, $value, $key);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_prepend')) {
|
|
/**
|
|
* Push an item onto the beginning of an array.
|
|
*
|
|
* @param array $array
|
|
* @param mixed $value
|
|
* @param mixed $key
|
|
* @return array
|
|
*/
|
|
function array_prepend($array, $value, $key = null)
|
|
{
|
|
return Arr::prepend($array, $value, $key);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_pull')) {
|
|
/**
|
|
* Get a value from the array, and remove it.
|
|
*
|
|
* @param array $array
|
|
* @param string $key
|
|
* @param mixed $default
|
|
* @return mixed
|
|
*/
|
|
function array_pull(&$array, $key, $default = null)
|
|
{
|
|
return Arr::pull($array, $key, $default);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_random')) {
|
|
/**
|
|
* Get a random value from an array.
|
|
*
|
|
* @param array $array
|
|
* @param int|null $num
|
|
* @return mixed
|
|
*/
|
|
function array_random($array, $num = null)
|
|
{
|
|
return Arr::random($array, $num);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_set')) {
|
|
/**
|
|
* Set an array item to a given value using "dot" notation.
|
|
*
|
|
* If no key is given to the method, the entire array will be replaced.
|
|
*
|
|
* @param array $array
|
|
* @param string $key
|
|
* @param mixed $value
|
|
* @return array
|
|
*/
|
|
function array_set(&$array, $key, $value)
|
|
{
|
|
return Arr::set($array, $key, $value);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_sort')) {
|
|
/**
|
|
* Sort the array by the given callback or attribute name.
|
|
*
|
|
* @param array $array
|
|
* @param callable|string|null $callback
|
|
* @return array
|
|
*/
|
|
function array_sort($array, $callback = null)
|
|
{
|
|
return Arr::sort($array, $callback);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_sort_recursive')) {
|
|
/**
|
|
* Recursively sort an array by keys and values.
|
|
*
|
|
* @param array $array
|
|
* @return array
|
|
*/
|
|
function array_sort_recursive($array)
|
|
{
|
|
return Arr::sortRecursive($array);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_where')) {
|
|
/**
|
|
* Filter the array using the given callback.
|
|
*
|
|
* @param array $array
|
|
* @param callable $callback
|
|
* @return array
|
|
*/
|
|
function array_where($array, callable $callback)
|
|
{
|
|
return Arr::where($array, $callback);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('array_wrap')) {
|
|
/**
|
|
* If the given value is not an array, wrap it in one.
|
|
*
|
|
* @param mixed $value
|
|
* @return array
|
|
*/
|
|
function array_wrap($value)
|
|
{
|
|
return Arr::wrap($value);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('blank')) {
|
|
/**
|
|
* Determine if the given value is "blank".
|
|
*
|
|
* @param mixed $value
|
|
* @return bool
|
|
*/
|
|
function blank($value)
|
|
{
|
|
if (is_null($value)) {
|
|
return true;
|
|
}
|
|
|
|
if (is_string($value)) {
|
|
return trim($value) === '';
|
|
}
|
|
|
|
if (is_numeric($value) || is_bool($value)) {
|
|
return false;
|
|
}
|
|
|
|
if ($value instanceof Countable) {
|
|
return count($value) === 0;
|
|
}
|
|
|
|
return empty($value);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('camel_case')) {
|
|
/**
|
|
* Convert a value to camel case.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
function camel_case($value)
|
|
{
|
|
return Str::camel($value);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('class_basename')) {
|
|
/**
|
|
* Get the class "basename" of the given object / class.
|
|
*
|
|
* @param string|object $class
|
|
* @return string
|
|
*/
|
|
function class_basename($class)
|
|
{
|
|
$class = is_object($class) ? get_class($class) : $class;
|
|
|
|
return basename(str_replace('\\', '/', $class));
|
|
}
|
|
}
|
|
|
|
if (! function_exists('class_uses_recursive')) {
|
|
/**
|
|
* Returns all traits used by a class, its subclasses and trait of their traits.
|
|
*
|
|
* @param object|string $class
|
|
* @return array
|
|
*/
|
|
function class_uses_recursive($class)
|
|
{
|
|
if (is_object($class)) {
|
|
$class = get_class($class);
|
|
}
|
|
|
|
$results = [];
|
|
|
|
foreach (array_merge([$class => $class], class_parents($class)) as $class) {
|
|
$results += trait_uses_recursive($class);
|
|
}
|
|
|
|
return array_unique($results);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('collect')) {
|
|
/**
|
|
* Create a collection from the given value.
|
|
*
|
|
* @param mixed $value
|
|
* @return \Illuminate\Support\Collection
|
|
*/
|
|
function collect($value = null)
|
|
{
|
|
return new Collection($value);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('data_fill')) {
|
|
/**
|
|
* Fill in data where it's missing.
|
|
*
|
|
* @param mixed $target
|
|
* @param string|array $key
|
|
* @param mixed $value
|
|
* @return mixed
|
|
*/
|
|
function data_fill(&$target, $key, $value)
|
|
{
|
|
return data_set($target, $key, $value, false);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('data_get')) {
|
|
/**
|
|
* Get an item from an array or object using "dot" notation.
|
|
*
|
|
* @param mixed $target
|
|
* @param string|array $key
|
|
* @param mixed $default
|
|
* @return mixed
|
|
*/
|
|
function data_get($target, $key, $default = null)
|
|
{
|
|
if (is_null($key)) {
|
|
return $target;
|
|
}
|
|
|
|
$key = is_array($key) ? $key : explode('.', $key);
|
|
|
|
while (! is_null($segment = array_shift($key))) {
|
|
if ($segment === '*') {
|
|
if ($target instanceof Collection) {
|
|
$target = $target->all();
|
|
} elseif (! is_array($target)) {
|
|
return value($default);
|
|
}
|
|
|
|
$result = Arr::pluck($target, $key);
|
|
|
|
return in_array('*', $key) ? Arr::collapse($result) : $result;
|
|
}
|
|
|
|
if (Arr::accessible($target) && Arr::exists($target, $segment)) {
|
|
$target = $target[$segment];
|
|
} elseif (is_object($target) && isset($target->{$segment})) {
|
|
$target = $target->{$segment};
|
|
} else {
|
|
return value($default);
|
|
}
|
|
}
|
|
|
|
return $target;
|
|
}
|
|
}
|
|
|
|
if (! function_exists('data_set')) {
|
|
/**
|
|
* Set an item on an array or object using dot notation.
|
|
*
|
|
* @param mixed $target
|
|
* @param string|array $key
|
|
* @param mixed $value
|
|
* @param bool $overwrite
|
|
* @return mixed
|
|
*/
|
|
function data_set(&$target, $key, $value, $overwrite = true)
|
|
{
|
|
$segments = is_array($key) ? $key : explode('.', $key);
|
|
|
|
if (($segment = array_shift($segments)) === '*') {
|
|
if (! Arr::accessible($target)) {
|
|
$target = [];
|
|
}
|
|
|
|
if ($segments) {
|
|
foreach ($target as &$inner) {
|
|
data_set($inner, $segments, $value, $overwrite);
|
|
}
|
|
} elseif ($overwrite) {
|
|
foreach ($target as &$inner) {
|
|
$inner = $value;
|
|
}
|
|
}
|
|
} elseif (Arr::accessible($target)) {
|
|
if ($segments) {
|
|
if (! Arr::exists($target, $segment)) {
|
|
$target[$segment] = [];
|
|
}
|
|
|
|
data_set($target[$segment], $segments, $value, $overwrite);
|
|
} elseif ($overwrite || ! Arr::exists($target, $segment)) {
|
|
$target[$segment] = $value;
|
|
}
|
|
} elseif (is_object($target)) {
|
|
if ($segments) {
|
|
if (! isset($target->{$segment})) {
|
|
$target->{$segment} = [];
|
|
}
|
|
|
|
data_set($target->{$segment}, $segments, $value, $overwrite);
|
|
} elseif ($overwrite || ! isset($target->{$segment})) {
|
|
$target->{$segment} = $value;
|
|
}
|
|
} else {
|
|
$target = [];
|
|
|
|
if ($segments) {
|
|
data_set($target[$segment], $segments, $value, $overwrite);
|
|
} elseif ($overwrite) {
|
|
$target[$segment] = $value;
|
|
}
|
|
}
|
|
|
|
return $target;
|
|
}
|
|
}
|
|
|
|
if (! function_exists('dd')) {
|
|
/**
|
|
* Dump the passed variables and end the script.
|
|
*
|
|
* @param mixed $args
|
|
* @return void
|
|
*/
|
|
function dd(...$args)
|
|
{
|
|
http_response_code(500);
|
|
|
|
foreach ($args as $x) {
|
|
(new Dumper)->dump($x);
|
|
}
|
|
|
|
die(1);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('e')) {
|
|
/**
|
|
* Escape HTML special characters in a string.
|
|
*
|
|
* @param \Illuminate\Contracts\Support\Htmlable|string $value
|
|
* @param bool $doubleEncode
|
|
* @return string
|
|
*/
|
|
function e($value, $doubleEncode = false)
|
|
{
|
|
if ($value instanceof Htmlable) {
|
|
return $value->toHtml();
|
|
}
|
|
|
|
return htmlspecialchars($value, ENT_QUOTES, 'UTF-8', $doubleEncode);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('ends_with')) {
|
|
/**
|
|
* Determine if a given string ends with a given substring.
|
|
*
|
|
* @param string $haystack
|
|
* @param string|array $needles
|
|
* @return bool
|
|
*/
|
|
function ends_with($haystack, $needles)
|
|
{
|
|
return Str::endsWith($haystack, $needles);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('env')) {
|
|
/**
|
|
* Gets the value of an environment variable.
|
|
*
|
|
* @param string $key
|
|
* @param mixed $default
|
|
* @return mixed
|
|
*/
|
|
function env($key, $default = null)
|
|
{
|
|
$value = getenv($key);
|
|
|
|
if ($value === false) {
|
|
return value($default);
|
|
}
|
|
|
|
switch (strtolower($value)) {
|
|
case 'true':
|
|
case '(true)':
|
|
return true;
|
|
case 'false':
|
|
case '(false)':
|
|
return false;
|
|
case 'empty':
|
|
case '(empty)':
|
|
return '';
|
|
case 'null':
|
|
case '(null)':
|
|
return;
|
|
}
|
|
|
|
if (strlen($value) > 1 && Str::startsWith($value, '"') && Str::endsWith($value, '"')) {
|
|
return substr($value, 1, -1);
|
|
}
|
|
|
|
return $value;
|
|
}
|
|
}
|
|
|
|
if (! function_exists('filled')) {
|
|
/**
|
|
* Determine if a value is "filled".
|
|
*
|
|
* @param mixed $value
|
|
* @return bool
|
|
*/
|
|
function filled($value)
|
|
{
|
|
return ! blank($value);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('head')) {
|
|
/**
|
|
* Get the first element of an array. Useful for method chaining.
|
|
*
|
|
* @param array $array
|
|
* @return mixed
|
|
*/
|
|
function head($array)
|
|
{
|
|
return reset($array);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('kebab_case')) {
|
|
/**
|
|
* Convert a string to kebab case.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
function kebab_case($value)
|
|
{
|
|
return Str::kebab($value);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('last')) {
|
|
/**
|
|
* Get the last element from an array.
|
|
*
|
|
* @param array $array
|
|
* @return mixed
|
|
*/
|
|
function last($array)
|
|
{
|
|
return end($array);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('object_get')) {
|
|
/**
|
|
* Get an item from an object using "dot" notation.
|
|
*
|
|
* @param object $object
|
|
* @param string $key
|
|
* @param mixed $default
|
|
* @return mixed
|
|
*/
|
|
function object_get($object, $key, $default = null)
|
|
{
|
|
if (is_null($key) || trim($key) == '') {
|
|
return $object;
|
|
}
|
|
|
|
foreach (explode('.', $key) as $segment) {
|
|
if (! is_object($object) || ! isset($object->{$segment})) {
|
|
return value($default);
|
|
}
|
|
|
|
$object = $object->{$segment};
|
|
}
|
|
|
|
return $object;
|
|
}
|
|
}
|
|
|
|
if (! function_exists('optional')) {
|
|
/**
|
|
* Provide access to optional objects.
|
|
*
|
|
* @param mixed $value
|
|
* @return mixed
|
|
*/
|
|
function optional($value = null)
|
|
{
|
|
return new Optional($value);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('preg_replace_array')) {
|
|
/**
|
|
* Replace a given pattern with each value in the array in sequentially.
|
|
*
|
|
* @param string $pattern
|
|
* @param array $replacements
|
|
* @param string $subject
|
|
* @return string
|
|
*/
|
|
function preg_replace_array($pattern, array $replacements, $subject)
|
|
{
|
|
return preg_replace_callback($pattern, function () use (&$replacements) {
|
|
foreach ($replacements as $key => $value) {
|
|
return array_shift($replacements);
|
|
}
|
|
}, $subject);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('retry')) {
|
|
/**
|
|
* Retry an operation a given number of times.
|
|
*
|
|
* @param int $times
|
|
* @param callable $callback
|
|
* @param int $sleep
|
|
* @return mixed
|
|
*
|
|
* @throws \Exception
|
|
*/
|
|
function retry($times, callable $callback, $sleep = 0)
|
|
{
|
|
$times--;
|
|
|
|
beginning:
|
|
try {
|
|
return $callback();
|
|
} catch (Exception $e) {
|
|
if (! $times) {
|
|
throw $e;
|
|
}
|
|
|
|
$times--;
|
|
|
|
if ($sleep) {
|
|
usleep($sleep * 1000);
|
|
}
|
|
|
|
goto beginning;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (! function_exists('snake_case')) {
|
|
/**
|
|
* Convert a string to snake case.
|
|
*
|
|
* @param string $value
|
|
* @param string $delimiter
|
|
* @return string
|
|
*/
|
|
function snake_case($value, $delimiter = '_')
|
|
{
|
|
return Str::snake($value, $delimiter);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('starts_with')) {
|
|
/**
|
|
* Determine if a given string starts with a given substring.
|
|
*
|
|
* @param string $haystack
|
|
* @param string|array $needles
|
|
* @return bool
|
|
*/
|
|
function starts_with($haystack, $needles)
|
|
{
|
|
return Str::startsWith($haystack, $needles);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('str_after')) {
|
|
/**
|
|
* Return the remainder of a string after a given value.
|
|
*
|
|
* @param string $subject
|
|
* @param string $search
|
|
* @return string
|
|
*/
|
|
function str_after($subject, $search)
|
|
{
|
|
return Str::after($subject, $search);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('str_before')) {
|
|
/**
|
|
* Get the portion of a string before a given value.
|
|
*
|
|
* @param string $subject
|
|
* @param string $search
|
|
* @return string
|
|
*/
|
|
function str_before($subject, $search)
|
|
{
|
|
return Str::before($subject, $search);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('str_contains')) {
|
|
/**
|
|
* Determine if a given string contains a given substring.
|
|
*
|
|
* @param string $haystack
|
|
* @param string|array $needles
|
|
* @return bool
|
|
*/
|
|
function str_contains($haystack, $needles)
|
|
{
|
|
return Str::contains($haystack, $needles);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('str_finish')) {
|
|
/**
|
|
* Cap a string with a single instance of a given value.
|
|
*
|
|
* @param string $value
|
|
* @param string $cap
|
|
* @return string
|
|
*/
|
|
function str_finish($value, $cap)
|
|
{
|
|
return Str::finish($value, $cap);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('str_is')) {
|
|
/**
|
|
* Determine if a given string matches a given pattern.
|
|
*
|
|
* @param string|array $pattern
|
|
* @param string $value
|
|
* @return bool
|
|
*/
|
|
function str_is($pattern, $value)
|
|
{
|
|
return Str::is($pattern, $value);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('str_limit')) {
|
|
/**
|
|
* Limit the number of characters in a string.
|
|
*
|
|
* @param string $value
|
|
* @param int $limit
|
|
* @param string $end
|
|
* @return string
|
|
*/
|
|
function str_limit($value, $limit = 100, $end = '...')
|
|
{
|
|
return Str::limit($value, $limit, $end);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('str_plural')) {
|
|
/**
|
|
* Get the plural form of an English word.
|
|
*
|
|
* @param string $value
|
|
* @param int $count
|
|
* @return string
|
|
*/
|
|
function str_plural($value, $count = 2)
|
|
{
|
|
return Str::plural($value, $count);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('str_random')) {
|
|
/**
|
|
* Generate a more truly "random" alpha-numeric string.
|
|
*
|
|
* @param int $length
|
|
* @return string
|
|
*
|
|
* @throws \RuntimeException
|
|
*/
|
|
function str_random($length = 16)
|
|
{
|
|
return Str::random($length);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('str_replace_array')) {
|
|
/**
|
|
* Replace a given value in the string sequentially with an array.
|
|
*
|
|
* @param string $search
|
|
* @param array $replace
|
|
* @param string $subject
|
|
* @return string
|
|
*/
|
|
function str_replace_array($search, array $replace, $subject)
|
|
{
|
|
return Str::replaceArray($search, $replace, $subject);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('str_replace_first')) {
|
|
/**
|
|
* Replace the first occurrence of a given value in the string.
|
|
*
|
|
* @param string $search
|
|
* @param string $replace
|
|
* @param string $subject
|
|
* @return string
|
|
*/
|
|
function str_replace_first($search, $replace, $subject)
|
|
{
|
|
return Str::replaceFirst($search, $replace, $subject);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('str_replace_last')) {
|
|
/**
|
|
* Replace the last occurrence of a given value in the string.
|
|
*
|
|
* @param string $search
|
|
* @param string $replace
|
|
* @param string $subject
|
|
* @return string
|
|
*/
|
|
function str_replace_last($search, $replace, $subject)
|
|
{
|
|
return Str::replaceLast($search, $replace, $subject);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('str_singular')) {
|
|
/**
|
|
* Get the singular form of an English word.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
function str_singular($value)
|
|
{
|
|
return Str::singular($value);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('str_slug')) {
|
|
/**
|
|
* Generate a URL friendly "slug" from a given string.
|
|
*
|
|
* @param string $title
|
|
* @param string $separator
|
|
* @param string $language
|
|
* @return string
|
|
*/
|
|
function str_slug($title, $separator = '-', $language = 'en')
|
|
{
|
|
return Str::slug($title, $separator, $language);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('str_start')) {
|
|
/**
|
|
* Begin a string with a single instance of a given value.
|
|
*
|
|
* @param string $value
|
|
* @param string $prefix
|
|
* @return string
|
|
*/
|
|
function str_start($value, $prefix)
|
|
{
|
|
return Str::start($value, $prefix);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('studly_case')) {
|
|
/**
|
|
* Convert a value to studly caps case.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
function studly_case($value)
|
|
{
|
|
return Str::studly($value);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('tap')) {
|
|
/**
|
|
* Call the given Closure with the given value then return the value.
|
|
*
|
|
* @param mixed $value
|
|
* @param callable|null $callback
|
|
* @return mixed
|
|
*/
|
|
function tap($value, $callback = null)
|
|
{
|
|
if (is_null($callback)) {
|
|
return new HigherOrderTapProxy($value);
|
|
}
|
|
|
|
$callback($value);
|
|
|
|
return $value;
|
|
}
|
|
}
|
|
|
|
if (! function_exists('throw_if')) {
|
|
/**
|
|
* Throw the given exception if the given condition is true.
|
|
*
|
|
* @param mixed $condition
|
|
* @param \Throwable|string $exception
|
|
* @param array ...$parameters
|
|
* @return mixed
|
|
* @throws \Throwable
|
|
*/
|
|
function throw_if($condition, $exception, ...$parameters)
|
|
{
|
|
if ($condition) {
|
|
throw (is_string($exception) ? new $exception(...$parameters) : $exception);
|
|
}
|
|
|
|
return $condition;
|
|
}
|
|
}
|
|
|
|
if (! function_exists('throw_unless')) {
|
|
/**
|
|
* Throw the given exception unless the given condition is true.
|
|
*
|
|
* @param mixed $condition
|
|
* @param \Throwable|string $exception
|
|
* @param array ...$parameters
|
|
* @return mixed
|
|
* @throws \Throwable
|
|
*/
|
|
function throw_unless($condition, $exception, ...$parameters)
|
|
{
|
|
if (! $condition) {
|
|
throw (is_string($exception) ? new $exception(...$parameters) : $exception);
|
|
}
|
|
|
|
return $condition;
|
|
}
|
|
}
|
|
|
|
if (! function_exists('title_case')) {
|
|
/**
|
|
* Convert a value to title case.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
function title_case($value)
|
|
{
|
|
return Str::title($value);
|
|
}
|
|
}
|
|
|
|
if (! function_exists('trait_uses_recursive')) {
|
|
/**
|
|
* Returns all traits used by a trait and its traits.
|
|
*
|
|
* @param string $trait
|
|
* @return array
|
|
*/
|
|
function trait_uses_recursive($trait)
|
|
{
|
|
$traits = class_uses($trait);
|
|
|
|
foreach ($traits as $trait) {
|
|
$traits += trait_uses_recursive($trait);
|
|
}
|
|
|
|
return $traits;
|
|
}
|
|
}
|
|
|
|
if (! function_exists('transform')) {
|
|
/**
|
|
* Transform the given value if it is present.
|
|
*
|
|
* @param mixed $value
|
|
* @param callable $callback
|
|
* @param mixed $default
|
|
* @return mixed|null
|
|
*/
|
|
function transform($value, callable $callback, $default = null)
|
|
{
|
|
if (filled($value)) {
|
|
return $callback($value);
|
|
}
|
|
|
|
if (is_callable($default)) {
|
|
return $default($value);
|
|
}
|
|
|
|
return $default;
|
|
}
|
|
}
|
|
|
|
if (! function_exists('value')) {
|
|
/**
|
|
* Return the default value of the given value.
|
|
*
|
|
* @param mixed $value
|
|
* @return mixed
|
|
*/
|
|
function value($value)
|
|
{
|
|
return $value instanceof Closure ? $value() : $value;
|
|
}
|
|
}
|
|
|
|
if (! function_exists('windows_os')) {
|
|
/**
|
|
* Determine whether the current environment is Windows based.
|
|
*
|
|
* @return bool
|
|
*/
|
|
function windows_os()
|
|
{
|
|
return strtolower(substr(PHP_OS, 0, 3)) === 'win';
|
|
}
|
|
}
|
|
|
|
if (! function_exists('with')) {
|
|
/**
|
|
* Return the given value, optionally passed through the given callback.
|
|
*
|
|
* @param mixed $value
|
|
* @param callable|null $callback
|
|
* @return mixed
|
|
*/
|
|
function with($value, callable $callback = null)
|
|
{
|
|
return is_null($callback) ? $value : $callback($value);
|
|
}
|
|
}
|