Subreality\Dilmun\Anshar\Utils\StringHelper

Complexity

Total Complexity

8

Size/Duplication

Total Lines	104
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

100%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	2
A	__toString()	0	4	1
A	affectChunks()	0	20	2
A	startsWith()	0	8	1
A	collapseStartingRepetition()	0	15	2

<?php
namespace Subreality\Dilmun\Anshar\Utils;

class StringHelper
{
    protected $string;

    /**
     * StringHelper constructor. Accepts and stores a string.
     *
     * @throws \InvalidArgumentException if not initialized with a string
     *
     * @param string $string    The string needing help
     */
    public function __construct($string)
    {
        if (!is_string($string)) {
            throw new \InvalidArgumentException("Supplied string is not a string");
        }

        $this->string = $string;
    }

    public function __toString()
    {
        return $this->string;
    }

    /**
     * Given a delimited string, returns a copy of the string with chunks defined by the delimiter affected by a given
     * function.
     *
     * The supplied function must be callable and must accept a string as its only required parameter
     *
     * @param callable $function    The function to be called against the delimited chunks; must be callable and must
     *                              accept a string as its only parameter
     * @param string[] $delimiters  One or more strings delimiting the chunks

Should the type for parameter $delimiters not be string[][]?

     *
     * @return string               A delimited string with chunks affected by the supplied function
     */
    public function affectChunks(callable $function, ...$delimiters)
    {
        $delimiter_string = "";
        $replace_callback = function ($matches) use ($function) {

            $callback_string = $function($matches[0]);

            return $callback_string;
        };

        foreach ($delimiters as $delimiter) {
            $delimiter_string .= preg_quote($delimiter, "/");
        }

        $pattern = "/[^{$delimiter_string}]+/";

        $affected_string = preg_replace_callback($pattern, $replace_callback, $this->string);

        return $affected_string;
    }

    /**
     * Determines whether the string starts with a given string.
     *
     * @param string $string    A string the string may or may not start with
     *
     * @return bool             Returns true if the string starts with the given string
     *                          Returns false if the string does not start with the given string
     */
    public function startsWith($string)
    {
        $pattern = "/^" . preg_quote($string, "/") . "/";

        $starts_with_string = preg_match($pattern, $this->string);

        return (bool) $starts_with_string;
    }

    /**
     * Given a string, collapses any repetition at the start of the string into a single instance of the given string.
     * If the given string does not exist at the start of the string, returns an unmodified string.
     *
     * For example, if the StringHelper was constructed with "ffoo", StringHelper::collapseStartingRepetition("f") will
     * return "foo". If the StringHelper was constructed with "foo", StringHelper::collapseStartingRepetition("b") will
     * also return "foo".
     *
     * @param string $string    A string the string may or may not start with, with or without repetition
     *
     * @return string           Returns a potentially modified string with a repeating, starting string collapsed into
     *                          a single instance of the string
     */
    public function collapseStartingRepetition($string)
    {
        $matches = array();
        $pattern = "/^[" . preg_quote($string, "/") . "]+(?P<remainder>.*)/";

        $starts_with_string = preg_match($pattern, $this->string, $matches);

        if ($starts_with_string) {
            $collapsed_string = $string . $matches["remainder"];

            return $collapsed_string;
        } else {
            return $this->string;
        }
    }
}