This library provides a collection of string processors.

This library is composer-enabled. The recommended way of using it in your project is to require it via composer.

composer require kolyunya/string-processor

Each processor implements the ProcessorInterface which contains the process method:

/**
 * Processes a string and returns a processed version of the original string.
 * @param string $string A string to process.
 * @return string A processed version of the original string.
 */
public function process($string);

Construct a processor and run process($string) on it:

$processor = new Processor();
echo $processor->process($string);

You can also use a processor without even instantiating it. Each processor has a static run method.

/**
 * Processes a string and returns a processed version of the original string.
 * @param string $string A string to process.
 * @param object|array $parameters Parameters passed to the processor's constructor.
 * @return string A processed version of the original string.
 */
public static function run($string, $parameters = array());

You can pass parameters to the processor's constructor in the $parameters array. You can also pass a single parameter without wrapping it into an array.

echo KebabCaseFormatter::run('snake_case'); // Output: "snake-case"
echo Translator::run(
    'Лорем ипсум долор сит амет',
    new RuEnDictionary()
); // Output: "Lorem ipsum dolor sit amet"

There is a special processor (Multiprocessor) which allows you to combine multiple processors in one. Suppose you want to convert a string to an UPPER-KEBAB case. You can combine two processors using Multiprocessor to solve this problem.

$processor = new Multiprocessor([
    new KebabCaseFormatter(),
    new UpperCaseFormatter(),
]);
echo $processor->process('snake_case'); // Output: "SNAKE-CASE"
echo $processor->process('CamelCase'); // Output: "CAMEL-CASE"

The UpperCaseFormatter will be applied after the KebabCaseFormatter. Note that either the processors order does not matter in the first example, it actually matters in the second one.

Another common problem example is to generate URL slugs. A string should be purified from punctuation characters, converted to the kebab-case and transliterated. Combine the PunctuationStripper, the KebabCaseFormatter and the Translator using Multiprocessor.

$processor = new Multiprocessor([
    new RuEnTranslator(),
    new AlphabeticalPurifier(),
    new KebabCaseFormatter(),
]);
echo $processor->process('Лорем ипсум долор сит амет'); // Output: "lorem-ipsum-dolor-sit-amet"
echo $processor->process('Привет, Мир!'); // Output: "privet-mir"

Each processor is a decorator. The ProcessorInterface contains the decorate method:

/**
 * Decorates supplied processor with the current processor.
 * @param ProcessorInterface $processor Processor to decorate.
 * @return ProcessorInterface Current processor.
 */
public function decorate(ProcessorInterface $processor);

That means that the above example can be implemented using processors decoration. The Multiprocessor usage is somewhat more readable though.

$processor =
(new RuEnTranslator())->decorate(
    (new KebabCaseFormatter())->decorate(
        (new PunctuationStripper())
    )
);
echo $processor->process('Лорем ипсум долор сит амет'); // Output: "lorem-ipsum-dolor-sit-amet"
echo $processor->process('Привет, Мир!'); // Output: "privet-mir"

Currently the following processors are implemented:

• Case switchers - format strings to arbitrary formats.
  • CamelCaseFormatter - formats a string to the CamelCase.
  • KebabCaseFormatter - formats a string to the kebab-case.
  • SnakeCaseFormatter - formats a string to the snake_case.
  • UpperCaseFormatter - formats a string to the UPPER CASE.
  • LowerCaseFormatter - formats a string to the lower case.
• Translators - transliterate strings from one language to another.
  • RuEnTranslator - transliterates strings from Russian to English and the other way around.
• Purifiers - purify strings.
  • PunctuationStripper - Strips punctuation characters.
  • AlphabeticalPurifier - Strips non-alphabetical characters.
• Multiprocessor - combines multiple processors.