Parser::findFormatter() - Code Metrics - yanmarques/lincable - Measure and Improve Code Quality continuously with Scrutinizer

Parser::findFormatter() A
last analyzed 2019-02-22 12:48 UTC

↳ Parent: Parser

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	1
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
c	0
b	0
f	0

<?php

namespace Lincable\Parsers;

use LogicException;
use Illuminate\Support\Collection;
use Lincable\Concerns\BuildClassnames;
use Lincable\Contracts\Formatters\Formatter;
use Illuminate\Contracts\Container\Container;
use Lincable\Contracts\Parsers\ParameterInterface;
use Lincable\Exceptions\NotDynamicOptionException;

abstract class Parser
{
    use BuildClassnames;

    /**
     * List with availables formatters.
     *
     * @var \Illuminate\Support\Collection
     */
    protected $formatters;

    /**
     * The application container implementation.
     *
     * @var \Illuminate\Contracts\Container\Container
     */
    protected $app;

    /**
     * Return the formatter call for the matches on parse.
     *
     * @param  array $matches
     * @return Lincable\Contracts\Parsers\ParameterInterface

     */
    abstract protected function parseMatches(array $matches): ParameterInterface;

    /**
     * Return the dynamic regex pattern.
     *
     * @return string
     */
    abstract protected function getDynamicPattern(): string;

    /**
     * Boot the parser with the container executing initial tasks.
     *
     * @param  \Illuminate\Contracts\Container\Container|null $app
     * @return void
     */
    public function boot(Container $app = null)
    {
        $this->formatters = collect();
        $this->app = $app;
    }

    /**
     * Push a new formatter to collection.
     *
     * @param  mixed $formatter
     * @param  string $name
     * @return this
     */
    public function addFormatter($formatter, string $name = null)
    {
        $this->formatters->put(
            $name ?: $this->nameFromClass($formatter, 'Formatter'),
            $formatter
        );

        return $this;
    }

    /**
     * Parse an option through formatters.
     *
     * @param  string $option
     * @return mixed
     * 
     * @throws Lincable\Exceptions\NotDynamicOption
     */
    public function parse(string $option)
    {
        if ($this->shouldParse($option)) {

            // Now that we have verified the option is dynamic and has
            // matches, we get the Option object from the implemented
            // method to deal with the matches.
            $parameter = $this->parseMatches($this->getMatches($option));

            // Return the content of the option executed.
            return $this->runForParameter($parameter);
        }

        throw new NotDynamicOptionException("Can not parse non dynamics parameter [$option].");
    }

    /**
     * Append a list of formatters.
     *
     * @param  mixed $formatters
     * @return this
     */
    public function addFormatters($formatters)
    {
        array_walk($formatters, function ($formatter, $name) {
            $this->addFormatter($formatter, is_int($name) ? null : $name);
        });

        return $this;
    }

    /**
     * Set the list with the new formatters.
     *
     * @param  \Illuminate\Support\Collection $formatters
     * @return this
     */
    public function setFormatters(Collection $formatters)
    {
        $this->formatters = $formatters;

        return $this;
    }

    /**
     * Return the formatters collection.
     *
     * @return \Illuminate\Support\Collection
     */
    public function getFormatters()
    {
        return $this->formatters;
    }

    /**
     * Return the containter instance.
     *
     * @return \Illuminate\Contracts\Container\Container
     */
    public function getContainer()
    {
        return $this->app;
    }

    /**
     * Set the new container instance.
     *
     * @param  \Illuminate\Contracts\Container\Container $app
     * @return this
     */
    public function setContainer(Container $app)
    {
        $this->app = $app;

        return $this;
    }

    /**
     * Return the first formatter that matches the option name.
     *
     * @param  string $option
     * @return mixed
     */
    public function findFormatter(string $option)
    {
        return $this->formatters->get($option);
    }

    /**
     * Determine wheter the parameter should be parsed.
     *
     * @param  string $option
     * @return bool
     */
    protected function shouldParse(string $option)
    {
        return $this->isParameterDynamic($option)
            && $this->getMatches($option);
    }

    /**
     * Run the parser for the parameter.
     *
     * @param  Lincable\Contracts\Parsers\ParameterInterface $parameter
     * @return mixed
     */
    protected function runForParameter(ParameterInterface $parameter)
    {
        // Get parameter value name.
        $name = $parameter->getValue();

        if ($formatter = $this->findFormatter($name)) {

            // Get a container callable.
            $callable = $this->resolveFormatter($formatter);

            // Execute the formatter class with the params.
            return $this->callFormatter(
                $callable,
                $parameter->getParams()
            );
        }

        throw new LogicException("Call to undefined formatter [{$name}].");
    }

    /**
     * Resolve the formatter call using the container with the array parameters.
     * The formatter argument should be a callable for the container.
     *
     * @param  mixed $formatter
     * @param  array $params
     * @return mixed
     */
    protected function callFormatter($formatter, array $params = [])
    {
        return $this->getContainer()->call($formatter, $params);
    }

    /**
     * Resolve a formatter to a container callable.
     *
     * @param  mixed $formatter
     * @return mixed
     */
    protected function resolveFormatter($formatter)
    {
        if (is_callable($formatter)) {

            // Just return the closure.
            return $formatter;
        }

        if (is_string($formatter)) {

            // Try to create formatter instance using dependency injection.
            $formatter = $this->getContainer()->make($formatter);
        }

        return [$formatter, 'format'];
    }

    /**
     * Determine wheter the parameter is dynamic.
     *
     * @param  string $parameter
     * @return bool
     */
    public function isParameterDynamic(string $parameter)
    {
        return (bool) preg_match($this->getDynamicPattern(), $parameter);
    }

    /**
     * Return the matches.
     *
     * @param  string $parameter
     * @return array
     */
    public function getMatches(string $parameter)
    {
        $isDynamic = preg_match(
            $this->getDynamicPattern(),
            $parameter,
            $matches
        );

        if ($isDynamic) {

            // The parameter is dynamic and has matches, so remove the first
            // match, that only matches the whole word.
            array_shift($matches);
        }

        return $matches;
    }
}


1		<?php
2
3		namespace Lincable\Parsers;
4
5		use LogicException;
6		use Illuminate\Support\Collection;
7		use Lincable\Concerns\BuildClassnames;
8		use Lincable\Contracts\Formatters\Formatter;
9		use Illuminate\Contracts\Container\Container;
10		use Lincable\Contracts\Parsers\ParameterInterface;
11		use Lincable\Exceptions\NotDynamicOptionException;
12
13		abstract class Parser
14		{
15		use BuildClassnames;
16
17		/**
18		* List with availables formatters.
19		*
20		* @var \Illuminate\Support\Collection
21		*/
22		protected $formatters;
23
24		/**
25		* The application container implementation.
26		*
27		* @var \Illuminate\Contracts\Container\Container
28		*/
29		protected $app;
30
31		/**
32		* Return the formatter call for the matches on parse.
33		*
34		* @param array $matches
35		* @return Lincable\Contracts\Parsers\ParameterInterface
		0 ignored issues – show Bug introduced 2018-07-04 03:45 UTC by Report Bug Copy Issue Report The type `Lincable\Parsers\Lincabl...sers\ParameterInterface` was not found. Did you mean `Lincable\Contracts\Parsers\ParameterInterface`? If so, make sure to prefix the type with `\`. Loading history...
36		*/
37		abstract protected function parseMatches(array $matches): ParameterInterface;
38
39		/**
40		* Return the dynamic regex pattern.
41		*
42		* @return string
43		*/
44		abstract protected function getDynamicPattern(): string;
45
46		/**
47		* Boot the parser with the container executing initial tasks.
48		*
49		* @param \Illuminate\Contracts\Container\Container\|null $app
50		* @return void
51		*/
52	66	public function boot(Container $app = null)
53		{
54	66	$this->formatters = collect();
55	66	$this->app = $app;
56	66	}
57
58		/**
59		* Push a new formatter to collection.
60		*
61		* @param mixed $formatter
62		* @param string $name
63		* @return this
64		*/
65	54	public function addFormatter($formatter, string $name = null)
66		{
67	54	$this->formatters->put(
68	54	$name ?: $this->nameFromClass($formatter, 'Formatter'),
69	54	$formatter
70		);
71
72	54	return $this;
73		}
74
75		/**
76		* Parse an option through formatters.
77		*
78		* @param string $option
79		* @return mixed
80		*
81		* @throws Lincable\Exceptions\NotDynamicOption
82		*/
83	42	public function parse(string $option)
84		{
85	42	if ($this->shouldParse($option)) {
86
87		// Now that we have verified the option is dynamic and has
88		// matches, we get the Option object from the implemented
89		// method to deal with the matches.
90	41	$parameter = $this->parseMatches($this->getMatches($option));
91
92		// Return the content of the option executed.
93	41	return $this->runForParameter($parameter);
94		}
95
96	1	throw new NotDynamicOptionException("Can not parse non dynamics parameter [$option].");
97		}
98
99		/**
100		* Append a list of formatters.
101		*
102		* @param mixed $formatters
103		* @return this
104		*/
105	40	public function addFormatters($formatters)
106		{
107		array_walk($formatters, function ($formatter, $name) {
108	40	$this->addFormatter($formatter, is_int($name) ? null : $name);
109	40	});
110
111	40	return $this;
112		}
113
114		/**
115		* Set the list with the new formatters.
116		*
117		* @param \Illuminate\Support\Collection $formatters
118		* @return this
119		*/
120		public function setFormatters(Collection $formatters)
121		{
122		$this->formatters = $formatters;
123
124		return $this;
125		}
126
127		/**
128		* Return the formatters collection.
129		*
130		* @return \Illuminate\Support\Collection
131		*/
132	2	public function getFormatters()
133		{
134	2	return $this->formatters;
135		}
136
137		/**
138		* Return the containter instance.
139		*
140		* @return \Illuminate\Contracts\Container\Container
141		*/
142	39	public function getContainer()
143		{
144	39	return $this->app;
145		}
146
147		/**
148		* Set the new container instance.
149		*
150		* @param \Illuminate\Contracts\Container\Container $app
151		* @return this
152		*/
153	1	public function setContainer(Container $app)
154		{
155	1	$this->app = $app;
156
157	1	return $this;
158		}
159
160		/**
161		* Return the first formatter that matches the option name.
162		*
163		* @param string $option
164		* @return mixed
165		*/
166	42	public function findFormatter(string $option)
167		{
168	42	return $this->formatters->get($option);
169		}
170
171		/**
172		* Determine wheter the parameter should be parsed.
173		*
174		* @param string $option
175		* @return bool
176		*/
177	42	protected function shouldParse(string $option)
178		{
179	42	return $this->isParameterDynamic($option)
180	42	&& $this->getMatches($option);
181		}
182
183		/**
184		* Run the parser for the parameter.
185		*
186		* @param Lincable\Contracts\Parsers\ParameterInterface $parameter
187		* @return mixed
188		*/
189	41	protected function runForParameter(ParameterInterface $parameter)
190		{
191		// Get parameter value name.
192	41	$name = $parameter->getValue();
193
194	41	if ($formatter = $this->findFormatter($name)) {
195
196		// Get a container callable.
197	39	$callable = $this->resolveFormatter($formatter);
198
199		// Execute the formatter class with the params.
200	39	return $this->callFormatter(
201	39	$callable,
202	39	$parameter->getParams()
203		);
204		}
205
206	2	throw new LogicException("Call to undefined formatter [{$name}].");
207		}
208
209		/**
210		* Resolve the formatter call using the container with the array parameters.
211		* The formatter argument should be a callable for the container.
212		*
213		* @param mixed $formatter
214		* @param array $params
215		* @return mixed
216		*/
217	39	protected function callFormatter($formatter, array $params = [])
218		{
219	39	return $this->getContainer()->call($formatter, $params);
220		}
221
222		/**
223		* Resolve a formatter to a container callable.
224		*
225		* @param mixed $formatter
226		* @return mixed
227		*/
228	39	protected function resolveFormatter($formatter)
229		{
230	39	if (is_callable($formatter)) {
231
232		// Just return the closure.
233	33	return $formatter;
234		}
235
236	19	if (is_string($formatter)) {
237
238		// Try to create formatter instance using dependency injection.
239	18	$formatter = $this->getContainer()->make($formatter);
240		}
241
242	19	return [$formatter, 'format'];
243		}
244
245		/**
246		* Determine wheter the parameter is dynamic.
247		*
248		* @param string $parameter
249		* @return bool
250		*/
251	47	public function isParameterDynamic(string $parameter)
252		{
253	47	return (bool) preg_match($this->getDynamicPattern(), $parameter);
254		}
255
256		/**
257		* Return the matches.
258		*
259		* @param string $parameter
260		* @return array
261		*/
262	45	public function getMatches(string $parameter)
263		{
264	45	$isDynamic = preg_match(
265	45	$this->getDynamicPattern(),
266	45	$parameter,
267	45	$matches
268		);
269
270	45	if ($isDynamic) {
271
272		// The parameter is dynamic and has matches, so remove the first
273		// match, that only matches the whole word.
274	45	array_shift($matches);
275		}
276
277	45	return $matches;
278		}
279		}
280

yanmarques / lincable

Parser::findFormatter() A last analyzed 2019-02-22 12:48 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Parser::findFormatter() A
last analyzed 2019-02-22 12:48 UTC