Deprecated: Constant E_STRICT is deprecated in /var/www/PixelForce/vendor/symfony/error-handler/ErrorHandler.php on line 58

Deprecated: Constant E_STRICT is deprecated in /var/www/PixelForce/vendor/symfony/error-handler/ErrorHandler.php on line 76
Symfony Profiler

vendor/cocur/slugify/src/Slugify.php line 82

Open in your IDE?
  1. <?php
  3. /**
  4.  * This file is part of cocur/slugify.
  5.  *
  6.  * (c) Florian Eckerstorfer <florian@eckerstorfer.co>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Cocur\Slugify;
  14. use Cocur\Slugify\RuleProvider\DefaultRuleProvider;
  15. use Cocur\Slugify\RuleProvider\RuleProviderInterface;
  17. /**
  18.  * Slugify
  19.  *
  20.  * @package   Cocur\Slugify
  21.  * @author    Florian Eckerstorfer <florian@eckerstorfer.co>
  22.  * @author    Ivo Bathke <ivo.bathke@gmail.com>
  23.  * @author    Marchenko Alexandr
  24.  * @copyright 2012-2015 Florian Eckerstorfer
  25.  * @license   http://www.opensource.org/licenses/MIT The MIT License
  26.  */
  27. class Slugify implements SlugifyInterface
  28. {
  29.     public const LOWERCASE_NUMBERS_DASHES = '/[^A-Za-z0-9]+/';
  31.     /**
  32.      * @var array<string,string>
  33.      */
  34.     protected array $rules = [];
  36.     /**
  37.      * @var RuleProviderInterface
  38.      */
  39.     protected RuleProviderInterface $provider;
  41.     /**
  42.      * @var array<string,mixed>
  43.      */
  44.     protected array $options = [
  45.         'regexp'    => self::LOWERCASE_NUMBERS_DASHES,
  46.         'separator' => '-',
  47.         'lowercase' => true,
  48.         'lowercase_after_regexp' => false,
  49.         'trim' => true,
  50.         'strip_tags' => false,
  51.         'rulesets'  => [
  52.             'default',
  53.             // Languages are preferred if they appear later, list is ordered by number of
  54.             // websites in that language
  55.             // https://en.wikipedia.org/wiki/Languages_used_on_the_Internet#Content_languages_for_websites
  56.             'armenian',
  57.             'azerbaijani',
  58.             'burmese',
  59.             'hindi',
  60.             'georgian',
  61.             'norwegian',
  62.             'vietnamese',
  63.             'ukrainian',
  64.             'latvian',
  65.             'finnish',
  66.             'greek',
  67.             'czech',
  68.             'arabic',
  69.             'slovak',
  70.             'turkish',
  71.             'polish',
  72.             'german',
  73.             'russian',
  74.             'romanian'
  75.         ],
  76.     ];
  78.     /**
  79.      * @param array                 $options
  80.      * @param RuleProviderInterface $provider
  81.      */
  82.     public function __construct(array $options = [], RuleProviderInterface $provider = null)
  83.     {
  84.         $this->options  = array_merge($this->options, $options);
  85.         $this->provider = $provider ? $provider : new DefaultRuleProvider();
  87.         foreach ($this->options['rulesets'] as $ruleSet) {
  88.             $this->activateRuleSet($ruleSet);
  89.         }
  90.     }
  92.     /**
  93.      * Returns the slug-version of the string.
  94.      *
  95.      * @param string            $string  String to slugify
  96.      * @param string|array|null $options Options
  97.      *
  98.      * @return string Slugified version of the string
  99.      */
  100.     public function slugify(string $string, array|string|null $options = null): string
  101.     {
  102.         // BC: the second argument used to be the separator
  103.         if (is_string($options)) {
  104.             $separator            = $options;
  105.             $options              = [];
  106.             $options['separator'] = $separator;
  107.         }
  109.         $options = array_merge($this->options, (array) $options);
  111.         // Add a custom ruleset without touching the default rules
  112.         if (isset($options['ruleset'])) {
  113.             $rules = array_merge($this->rules, $this->provider->getRules($options['ruleset']));
  114.         } else {
  115.             $rules = $this->rules;
  116.         }
  118.         $string = ($options['strip_tags'])
  119.             ? strip_tags($string)
  120.             : $string;
  122.         $string = strtr($string, $rules);
  123.         unset($rules);
  125.         if ($options['lowercase'] && !$options['lowercase_after_regexp']) {
  126.             $string = mb_strtolower($string);
  127.         }
  129.         $string = preg_replace($options['regexp'], $options['separator'], $string);
  131.         if ($options['lowercase'] && $options['lowercase_after_regexp']) {
  132.             $string = mb_strtolower($string);
  133.         }
  135.         return ($options['trim'])
  136.             ? trim($string, $options['separator'])
  137.             : $string;
  138.     }
  140.     /**
  141.      * Adds a custom rule to Slugify.
  142.      *
  143.      * @param string $character   Character
  144.      * @param string $replacement Replacement character
  145.      *
  146.      * @return Slugify
  147.      */
  148.     public function addRule($character, $replacement): self
  149.     {
  150.         $this->rules[$character] = $replacement;
  152.         return $this;
  153.     }
  155.     /**
  156.      * Adds multiple rules to Slugify.
  157.      *
  158.      * @param array <string,string> $rules
  159.      *
  160.      * @return Slugify
  161.      */
  162.     public function addRules(array $rules): self
  163.     {
  164.         foreach ($rules as $character => $replacement) {
  165.             $this->addRule($character, $replacement);
  166.         }
  168.         return $this;
  169.     }
  171.     /**
  172.      * @param string $ruleSet
  173.      *
  174.      * @return Slugify
  175.      */
  176.     public function activateRuleSet($ruleSet): self
  177.     {
  178.         return $this->addRules($this->provider->getRules($ruleSet));
  179.     }
  181.     /**
  182.      * Static method to create new instance of {@see Slugify}.
  183.      *
  184.      * @param array <string,mixed> $options
  185.      *
  186.      * @return Slugify
  187.      */
  188.     public static function create(array $options = []): self
  189.     {
  190.         return new static($options);
  191.     }
  192. }