Translation::pushVars() - Code Metrics - webino/WebinoDraw - Measure and Improve Code Quality continuously with Scrutinizer

Translation::pushVars() B
last analyzed 2019-12-25 16:24 UTC

↳ Parent: Translation

Complexity

Conditions	9
Paths	38

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	38
rs	7.7564
c	0
b	0
f	0
cc	9
nc	38
nop	2

<?php
/**
 * Webino (http://webino.sk)
 *
 * @link        https://github.com/webino/WebinoDraw for the canonical source repository
 * @copyright   Copyright (c) 2012-2017 Webino, s. r. o. (http://webino.sk)
 * @author      Peter Bačinský <[email protected]>
 * @license     BSD-3-Clause
 */

namespace WebinoDraw\VarTranslator;

use ArrayAccess;
use ArrayObject;
use WebinoDraw\Stdlib\ArrayFetchInterface;
use WebinoDraw\Stdlib\ArrayMergeInterface;

/**
 * Class Translation
 */
class Translation extends ArrayObject implements
    ArrayFetchInterface,
    ArrayMergeInterface
{
    /**
     * Pattern of a variable
     */
    const VAR_PATTERN = '{$%s}';

    /**
     * Prefix of the extra variables to avoid conflicts
     */
    const EXTRA_VAR_PREFIX = '_';

    /**
     * Pattern to match variables
     *
     * @var string
     */
    protected $varPregPattern;

    /**
     * Return value in depth from multidimensional array
     *
     * @param string $basePath Something like: value.in.the.depth
     * @return mixed Result value
     */
    public function fetch($basePath)
    {
        $value = $this->getArrayCopy();
        foreach ($this->resolveBasePathParts($basePath) as $key) {
            // magic keys
            if ('_first' === $key) {
                reset($value);
                $key = key($value);

            } elseif ('_last' === $key) {
                end($value);
                $key = key($value);
            }

            // unescape
            $key = str_replace('\.', '.', $key);

            // undefined
            if (!array_key_exists($key, $value)) {
                $value = null;
                break;
            }

            $value = &$value[$key];

            // array only
            if (!is_array($value) && !($value instanceof ArrayObject)) {
                if (is_object($value)) {
                    if (method_exists($value, 'toArray')) {
                        $value = $value->toArray();
                    } elseif (method_exists($value, 'getArrayCopy')) {
                        $value = $value->getArrayCopy();
                    } else {
                        break;
                    }
                } else {
                    break;
                }
            }
        }

        return $value;
    }

    /**
     * @param array $array
     * @return $this
     */
    public function merge(array $array)
    {
        empty($array) or $this->exchangeArray(array_replace_recursive($this->getArrayCopy(), $array));
        return $this;
    }

    /**
     * @param array $keys
     * @return $this
     */
    public function unsetKeys(array $keys)
    {
        foreach ($keys as $key) {
            $this->offsetExists($key)
                and $this->offsetUnset($key);
        }

        return $this;
    }

    /**
     * @return $this
     */
    public function getVarTranslation()
    {
        return $this->makeVarKeys($this);
    }

    /**
     * @param string $varKey
     * @return string
     */
    public function makeExtraVarKey($varKey)
    {
        return self::EXTRA_VAR_PREFIX . $varKey;
    }

    /**
     * Transform varName into {$varName}.
     *
     * @param string $key
     * @return string
     */
    public function makeVar($key)
    {
        return sprintf(self::VAR_PATTERN, $key);
    }

    /**
     * Transform subject keys to {$var} like
     *
     * @param ArrayAccess $subject
     * @return ArrayAccess|self
     */
    public function makeVarKeys(ArrayAccess $subject = null)
    {
        $_subject     = (null !== $subject) ? $_subject = $subject : $_subject = $this;
        $subjectClone = clone $_subject;

        foreach ($_subject as $key => $value) {
            $subjectClone->offsetSet($this->makeVar($key), $value);
            $subjectClone->offsetUnset($key);
        }

        return $subjectClone;
    }

    /**
     * Match {$var} regular pattern
     *
     * @return string
     */
    public function getVarPregPattern()
    {
        if (null === $this->varPregPattern) {
            $pattern = str_replace('%s', '[^\}]+', preg_quote(self::VAR_PATTERN));
            $this->varPregPattern = '~' . $pattern . '~';
        }
        return $this->varPregPattern;
    }

    /**
     * Return true if {$var} is in the string
     *
     * @param string $string
     * @return bool
     */
    public function containsVar($string)
    {
        return (bool) preg_match($this->getVarPregPattern(), $string);
    }

    /**
     * Remove vars from string
     *
     * @param string $string
     * @return bool
     */
    public function removeVars($string)
    {
        if (!is_string($string) || !$this->containsVar($string)) {
            return $string;
        }
        return trim(preg_replace($this->getVarPregPattern(), '', $string));
    }

    /**
     * Replace {$var} in string with data from translation
     *
     * If $str = {$var} and translation has item with key {$var} = array,
     * immediately return this array.
     *
     * @param string $str
     * @return mixed
     */
    public function translateString($str)
    {
        if (!is_string($str)) {
            return $str;
        }

        $match = [];
        preg_match_all($this->getVarPregPattern(), $str, $match);

        if (empty($match[0])) {
            return $str;
        }

        foreach ($match[0] as $key) {
            if (!$this->offsetExists($key)) {
                continue;
            }

            $value = $this->offsetGet($key);
            if ($key === $str
                && (is_object($value)
                    || is_array($value)
                    || is_int($value)
                    || is_float($value))
            ) {
                // return early for non-strings
                // this is useful to pass subjects
                // to functions, helpers and filters
                return $value;
            }

            $str = str_replace($key, $value, $str);
        }

        return $str;
    }

    /**
     * Replace {$var} in $subject with data from $translation
     *
     * @param string|array $subject
     * @return $this
     */
    public function translate(&$subject)
    {
        if (empty($subject)) {
            return $this;
        }

        if (is_string($subject)) {
            $subject = $this->translateString($subject);
            return $this;
        }

        if (!is_array($subject)) {
            return $this;
        }

        foreach ($subject as &$param) {
            if (is_array($param)) {
                $this->translate($param);
                continue;
            }

            $param = $this->translateString($param);
        }

        return $this;
    }

    /**
     * @param array $values
     * @return $this
     */
    public function mergeValues(array $values)
    {
        foreach ($values as $key => $value) {
            $this->getVarTranslation()->translate($value);
            $this->offsetSet($key, $value);
        }
        return $this;
    }

    /**
     * Set translated defaults into translation
     *
     * @param array $defaults
     * @return array
     */
    public function setDefaults(array $defaults)
    {
        foreach ($defaults as $key => $defaultValue) {
            if (!$this->offsetExists($key)) {
                $this->setDefault($key, $defaultValue);
                continue;
            }

            $value = $this->offsetGet($key);
            if (empty($value) && !is_numeric($value)) {
                $this->setDefault($key, $defaultValue);
            }
        }

        return $this;
    }

    /**
     * @param mixed $key
     * @param mixed $value
     * @return $this
     */
    protected function setDefault($key, $value)
    {
        $this->getVarTranslation()->translate($value);
        $this->offsetSet($key, $value);
        return $this;
    }

    /**
     * Fetch custom variables into translation
     *
     * example of properties:
     * <pre>
     * $translation = [
     *     'value' => [
     *         'in' => [
     *             'the' => [
     *                 'depth' => 'valueInTheDepth',
     *             ],
     *         ],
     *     ],
     * ];
     * </pre>
     *
     * example of options:
     *
     * <pre>
     * $options = [
     *     'customVar' => 'value.in.the.depth',
     * ];
     * </pre>
     *
     * @param array $options
     * @return $this
     */
    public function fetchVars(array $options)
    {
        foreach ($options as $key => $basePath) {
            $this->offsetSet($key, $this->fetch($this->getVarTranslation()->translateString($basePath)));
        }
        return $this;
    }

    /**
     * Push variables into translation
     *
     * @param array $options
     * @param self $translation
     * @return $this
     */
    public function pushVars(array $options, self $translation = null)
    {
        $translation and $translation->getVarTranslation()->translate($options);

        foreach ($options as $basePath => $value) {
            $key      = 0;
            $index    = null;
            $create   = false;
            $subValue = $this;

            foreach ($this->resolveBasePathParts($basePath) as $key) {
                if (null === $index) {
                    $index = $key;
                }

                if ($create) {
                    $create   = false;
                    $subValue = new ArrayObject;
                }

                // undefined
                if (!array_key_exists($key, $subValue) || is_scalar($value)) {
                    // create or override scalar
                    $create = true;
                    continue;
                }

                $subValue = &$subValue[$key];
            }

            $subValue[$key] = $value;
            if ($this !== $subValue) {
                $this->offsetSet($index, $subValue);
            }
        }

        return $this;
    }

    /**
     * Explode path by dots and return those parts
     *
     * @param string $basePath
     * @return array
     */
    private function resolveBasePathParts($basePath)
    {
        $parts = [];
        preg_match_all('~[^\.]+\\\.[^\.]+|[^\.]+~', $basePath, $parts);
        return $parts[0];
    }
}


1			<?php
2			/**
3			* Webino (http://webino.sk)
4			*
5			* @link https://github.com/webino/WebinoDraw for the canonical source repository
6			* @copyright Copyright (c) 2012-2017 Webino, s. r. o. (http://webino.sk)
7			* @author Peter Bačinský <[email protected]>
8			* @license BSD-3-Clause
9			*/
10
11			namespace WebinoDraw\VarTranslator;
12
13			use ArrayAccess;
14			use ArrayObject;
15			use WebinoDraw\Stdlib\ArrayFetchInterface;
16			use WebinoDraw\Stdlib\ArrayMergeInterface;
17
18			/**
19			* Class Translation
20			*/
21			class Translation extends ArrayObject implements
22			ArrayFetchInterface,
23			ArrayMergeInterface
24			{
25			/**
26			* Pattern of a variable
27			*/
28			const VAR_PATTERN = '{$%s}';
29
30			/**
31			* Prefix of the extra variables to avoid conflicts
32			*/
33			const EXTRA_VAR_PREFIX = '_';
34
35			/**
36			* Pattern to match variables
37			*
38			* @var string
39			*/
40			protected $varPregPattern;
41
42			/**
43			* Return value in depth from multidimensional array
44			*
45			* @param string $basePath Something like: value.in.the.depth
46			* @return mixed Result value
47			*/
48			public function fetch($basePath)
49			{
50			$value = $this->getArrayCopy();
51			foreach ($this->resolveBasePathParts($basePath) as $key) {
52			// magic keys
53			if ('_first' === $key) {
54			reset($value);
55			$key = key($value);
56
57			} elseif ('_last' === $key) {
58			end($value);
59			$key = key($value);
60			}
61
62			// unescape
63			$key = str_replace('\.', '.', $key);
64
65			// undefined
66			if (!array_key_exists($key, $value)) {
67			$value = null;
68			break;
69			}
70
71			$value = &$value[$key];
72
73			// array only
74			if (!is_array($value) && !($value instanceof ArrayObject)) {
75			if (is_object($value)) {
76			if (method_exists($value, 'toArray')) {
77			$value = $value->toArray();
78			} elseif (method_exists($value, 'getArrayCopy')) {
79			$value = $value->getArrayCopy();
80			} else {
81			break;
82			}
83			} else {
84			break;
85			}
86			}
87			}
88
89			return $value;
90			}
91
92			/**
93			* @param array $array
94			* @return $this
95			*/
96			public function merge(array $array)
97			{
98			empty($array) or $this->exchangeArray(array_replace_recursive($this->getArrayCopy(), $array));
99			return $this;
100			}
101
102			/**
103			* @param array $keys
104			* @return $this
105			*/
106			public function unsetKeys(array $keys)
107			{
108			foreach ($keys as $key) {
109			$this->offsetExists($key)
110			and $this->offsetUnset($key);
111			}
112
113			return $this;
114			}
115
116			/**
117			* @return $this
118			*/
119			public function getVarTranslation()
120			{
121			return $this->makeVarKeys($this);
122			}
123
124			/**
125			* @param string $varKey
126			* @return string
127			*/
128			public function makeExtraVarKey($varKey)
129			{
130			return self::EXTRA_VAR_PREFIX . $varKey;
131			}
132
133			/**
134			* Transform varName into {$varName}.
135			*
136			* @param string $key
137			* @return string
138			*/
139			public function makeVar($key)
140			{
141			return sprintf(self::VAR_PATTERN, $key);
142			}
143
144			/**
145			* Transform subject keys to {$var} like
146			*
147			* @param ArrayAccess $subject
148			* @return ArrayAccess\|self
149			*/
150			public function makeVarKeys(ArrayAccess $subject = null)
151			{
152			$_subject = (null !== $subject) ? $_subject = $subject : $_subject = $this;
153			$subjectClone = clone $_subject;
154
155			foreach ($_subject as $key => $value) {
156			$subjectClone->offsetSet($this->makeVar($key), $value);
157			$subjectClone->offsetUnset($key);
158			}
159
160			return $subjectClone;
161			}
162
163			/**
164			* Match {$var} regular pattern
165			*
166			* @return string
167			*/
168			public function getVarPregPattern()
169			{
170			if (null === $this->varPregPattern) {
171			$pattern = str_replace('%s', '[^\}]+', preg_quote(self::VAR_PATTERN));
172			$this->varPregPattern = '~' . $pattern . '~';
173			}
174			return $this->varPregPattern;
175			}
176
177			/**
178			* Return true if {$var} is in the string
179			*
180			* @param string $string
181			* @return bool
182			*/
183			public function containsVar($string)
184			{
185			return (bool) preg_match($this->getVarPregPattern(), $string);
186			}
187
188			/**
189			* Remove vars from string
190			*
191			* @param string $string
192			* @return bool
193			*/
194			public function removeVars($string)
195			{
196			if (!is_string($string) \|\| !$this->containsVar($string)) {
197			return $string;
198			}
199			return trim(preg_replace($this->getVarPregPattern(), '', $string));
200			}
201
202			/**
203			* Replace {$var} in string with data from translation
204			*
205			* If $str = {$var} and translation has item with key {$var} = array,
206			* immediately return this array.
207			*
208			* @param string $str
209			* @return mixed
210			*/
211			public function translateString($str)
212			{
213			if (!is_string($str)) {
214			return $str;
215			}
216
217			$match = [];
218			preg_match_all($this->getVarPregPattern(), $str, $match);
219
220			if (empty($match[0])) {
221			return $str;
222			}
223
224			foreach ($match[0] as $key) {
225			if (!$this->offsetExists($key)) {
226			continue;
227			}
228
229			$value = $this->offsetGet($key);
230			if ($key === $str
231			&& (is_object($value)
232			\|\| is_array($value)
233			\|\| is_int($value)
234			\|\| is_float($value))
235			) {
236			// return early for non-strings
237			// this is useful to pass subjects
238			// to functions, helpers and filters
239			return $value;
240			}
241
242			$str = str_replace($key, $value, $str);
243			}
244
245			return $str;
246			}
247
248			/**
249			* Replace {$var} in $subject with data from $translation
250			*
251			* @param string\|array $subject
252			* @return $this
253			*/
254			public function translate(&$subject)
255			{
256			if (empty($subject)) {
257			return $this;
258			}
259
260			if (is_string($subject)) {
261			$subject = $this->translateString($subject);
262			return $this;
263			}
264
265			if (!is_array($subject)) {
266			return $this;
267			}
268
269			foreach ($subject as &$param) {
270			if (is_array($param)) {
271			$this->translate($param);
272			continue;
273			}
274
275			$param = $this->translateString($param);
276			}
277
278			return $this;
279			}
280
281			/**
282			* @param array $values
283			* @return $this
284			*/
285			public function mergeValues(array $values)
286			{
287			foreach ($values as $key => $value) {
288			$this->getVarTranslation()->translate($value);
289			$this->offsetSet($key, $value);
290			}
291			return $this;
292			}
293
294			/**
295			* Set translated defaults into translation
296			*
297			* @param array $defaults
298			* @return array
299			*/
300			public function setDefaults(array $defaults)
301			{
302			foreach ($defaults as $key => $defaultValue) {
303			if (!$this->offsetExists($key)) {
304			$this->setDefault($key, $defaultValue);
305			continue;
306			}
307
308			$value = $this->offsetGet($key);
309			if (empty($value) && !is_numeric($value)) {
310			$this->setDefault($key, $defaultValue);
311			}
312			}
313
314			return $this;
315			}
316
317			/**
318			* @param mixed $key
319			* @param mixed $value
320			* @return $this
321			*/
322			protected function setDefault($key, $value)
323			{
324			$this->getVarTranslation()->translate($value);
325			$this->offsetSet($key, $value);
326			return $this;
327			}
328
329			/**
330			* Fetch custom variables into translation
331			*
332			* example of properties:
333			* <pre>
334			* $translation = [
335			* 'value' => [
336			* 'in' => [
337			* 'the' => [
338			* 'depth' => 'valueInTheDepth',
339			* ],
340			* ],
341			* ],
342			* ];
343			* </pre>
344			*
345			* example of options:
346			*
347			* <pre>
348			* $options = [
349			* 'customVar' => 'value.in.the.depth',
350			* ];
351			* </pre>
352			*
353			* @param array $options
354			* @return $this
355			*/
356			public function fetchVars(array $options)
357			{
358			foreach ($options as $key => $basePath) {
359			$this->offsetSet($key, $this->fetch($this->getVarTranslation()->translateString($basePath)));
360			}
361			return $this;
362			}
363
364			/**
365			* Push variables into translation
366			*
367			* @param array $options
368			* @param self $translation
369			* @return $this
370			*/
371			public function pushVars(array $options, self $translation = null)
372			{
373			$translation and $translation->getVarTranslation()->translate($options);
374
375			foreach ($options as $basePath => $value) {
376			$key = 0;
377			$index = null;
378			$create = false;
379			$subValue = $this;
380
381			foreach ($this->resolveBasePathParts($basePath) as $key) {
382			if (null === $index) {
383			$index = $key;
384			}
385
386			if ($create) {
387			$create = false;
388			$subValue = new ArrayObject;
389			}
390
391			// undefined
392			if (!array_key_exists($key, $subValue) \|\| is_scalar($value)) {
393			// create or override scalar
394			$create = true;
395			continue;
396			}
397
398			$subValue = &$subValue[$key];
399			}
400
401			$subValue[$key] = $value;
402			if ($this !== $subValue) {
403			$this->offsetSet($index, $subValue);
404			}
405			}
406
407			return $this;
408			}
409
410			/**
411			* Explode path by dots and return those parts
412			*
413			* @param string $basePath
414			* @return array
415			*/
416			private function resolveBasePathParts($basePath)
417			{
418			$parts = [];
419			preg_match_all('~[^\.]+\\\.[^\.]+\|[^\.]+~', $basePath, $parts);
420			return $parts[0];
421			}
422			}
423

webino / WebinoDraw

Translation::pushVars() B last analyzed 2019-12-25 16:24 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Translation::pushVars() B
last analyzed 2019-12-25 16:24 UTC