Generator::conditionUriRegex() - Code Metrics - krzysztof-magosa/saffron-php - Measure and Improve Code Quality continuously with Scrutinizer

Generator::conditionUriRegex() A
last analyzed 2019-10-29 21:40 UTC

↳ Parent: Generator

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	11
rs	9.9
c	0
b	0
f	0
cc	2
nc	2
nop	2

<?php
/**
 * Copyright 2014 Krzysztof Magosa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
namespace KM\Saffron\UrlMatcher;

use KM\Saffron\RoutesCollection;
use KM\Saffron\Route;
use KM\Saffron\Code;

class Generator extends \KM\Saffron\Generator
{
    /**
     * @var RoutesCollection
     */
    protected $collection;

    /**
     * @var Code
     */
    protected $code;

    public function __construct(RoutesCollection $collection)
    {
        $this->collection = $collection;
        $this->code = new Code();
    }

    protected function conditionPrefix(Route $route, &$conditions)
    {
        $compiled = $route->getCompiled();

        if ($compiled->hasUriRegex()) {
            $conditions[] = sprintf(
                '0 === strpos($uri, %s)',
                var_export($compiled->getPrefix(), true)
            );
        } else {
            $conditions[] = sprintf(
                '$uri == %s',
                var_export($compiled->getPrefix(), true)
            );
        }
    }

    protected function conditionUriRegex(Route $route, array &$conditions)
    {
        $compiled = $route->getCompiled();

        if ($compiled->hasUriRegex()) {
            $conditions[] = sprintf(
                'preg_match(%s, $uri, $uriMatch)',
                var_export($compiled->getUriRegex(), true)
            );
        }
    }

    protected function conditionHttps(Route $route, array &$conditions)
    {
        if ($route->hasHttps()) {
            $conditions[] = sprintf(
                '$https === %s',
                var_export($route->getHttps(), true)
            );
        }
    }

    protected function getArraysOfParameters(Route $route)
    {
        $arrays = [];
        $compiled = $route->getCompiled();

        $arrays[] = sprintf(
            "['_route' => %s, '_request' => \$request]",
            var_export($route->getName(), true)
        );

        if ($route->hasDefaults()) {
            $arrays[] = $this->formatArray($route->getDefaults());
        }

        if ($route->hasDomain()) {
            $arrays[] = '$domainMatch';
        }
        if ($compiled->hasUriRegex()) {
            $arrays[] = '$uriMatch';
        }

        return $arrays;
    }

    protected function generateRoute(Route $route)
    {
        $conditions = [];
        $this->conditionPrefix($route, $conditions);
        $this->conditionUriRegex($route, $conditions);
        $this->conditionHttps($route, $conditions);

        $this->code->append(
            sprintf(
                'if (%s) {',
                implode(' && ', $conditions)
            )
        );

        if ($route->hasMethod()) {
            $this->code->append(
                sprintf(
                    'if (in_array($method, %s)) {',
                    $this->formatArray($route->getMethod())
                )
            );
        }

        $this->code
            ->append('return new RoutingResult(')
            ->append('true,')
            ->append('false,')
            ->append('false,')
            ->append('[],')
            ->append($this->formatArray($route->getTarget()).',');

        $arrays = $this->getArraysOfParameters($route);
        if (count($arrays) >= 2) {
            $this->code->append(
                sprintf(
                    '$this->filterParameters(array_replace(%s))',
                    implode(', ', $this->getArraysOfParameters($route))
                )
            );
        } else {
            $this->code->append(
                sprintf(
                    '$this->filterParameters(%s)',
                    $this->getArraysOfParameters($route)[0]
                )
            );
        }

        $this->code->append(');');

        if ($route->hasMethod()) {
            $this->code->append('}');
            $this->code->append('else {');
            $this->code->append(
                sprintf(
                    '$allowedMethods = array_merge($allowedMethods, %s);',
                    $this->formatArray($route->getMethod())
                )
            );
            $this->code->append('}');
        }

        $this->code->append('}');
    }

    protected function generateMatchMethod()
    {
        $this->code
            ->append('public function match(Request $request) {')
            ->append('$uri = $request->getUri();')
            ->append('$allowedMethods = [];');

        if ($this->collection->hasDomain()) {
            $this->code->append('$domain = $request->getDomain();');
        }

        if ($this->collection->hasHttps()) {
            $this->code->append('$https = $request->getHttps();');
        }

        if ($this->collection->hasMethod()) {
            $this->code->append('$method = $request->getMethod();');
        }

        foreach ($this->collection->groupByDomain() as $routes) {
            if ($routes->first()->hasDomain()) {
                $this->code->append(
                    sprintf(
                        'if (preg_match(%s, $domain, $domainMatch)) {',
                        var_export(
                            $routes->first()->getCompiled()->getDomainRegex(),
                            true
                        )
                    )
                );
            }

            foreach ($routes as $route) {
                $this->generateRoute($route);
            }

            if ($routes->first()->hasDomain()) {
                $this->code->append('}');
            }
        }

        $this->code
            ->append('return new RoutingResult(')
            ->append('false,')
            ->append('!empty($allowedMethods),')
            ->append('empty($allowedMethods),')
            ->append('array_unique($allowedMethods),')
            ->append('[],')
            ->append('[]')
            ->append(');');

        $this->code->append('}');
    }

    /**
     * @param string $className
     */
    protected function generateHeader($className)
    {
        $this->code->append(
<<<EOB
            <?php
            use KM\Saffron\UrlMatcher;
            use KM\Saffron\Request;
            use KM\Saffron\RoutingResult;
            use KM\Saffron\UrlMatcher\Base;

            class $className extends Base {
EOB
        );
    }

    protected function generateFooter()
    {
        $this->code->append('}');
    }

    /**
     * @param string $className
     * @return string
     */
    public function generate($className)
    {
        $this->generateHeader($className);
        $this->generateMatchMethod();
        $this->generateFooter();

        return (string)$this->code;
    }
}


1			<?php
2			/**
3			* Copyright 2014 Krzysztof Magosa
4			*
5			* Licensed under the Apache License, Version 2.0 (the "License");
6			* you may not use this file except in compliance with the License.
7			* You may obtain a copy of the License at
8			* http://www.apache.org/licenses/LICENSE-2.0
9			*
10			* Unless required by applicable law or agreed to in writing, software
11			* distributed under the License is distributed on an "AS IS" BASIS,
12			* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13			* See the License for the specific language governing permissions and
14			* limitations under the License.
15			*/
16			namespace KM\Saffron\UrlMatcher;
17
18			use KM\Saffron\RoutesCollection;
19			use KM\Saffron\Route;
20			use KM\Saffron\Code;
21
22			class Generator extends \KM\Saffron\Generator
23			{
24			/**
25			* @var RoutesCollection
26			*/
27			protected $collection;
28
29			/**
30			* @var Code
31			*/
32			protected $code;
33
34			public function __construct(RoutesCollection $collection)
35			{
36			$this->collection = $collection;
37			$this->code = new Code();
38			}
39
40			protected function conditionPrefix(Route $route, &$conditions)
41			{
42			$compiled = $route->getCompiled();
43
44			if ($compiled->hasUriRegex()) {
45			$conditions[] = sprintf(
46			'0 === strpos($uri, %s)',
47			var_export($compiled->getPrefix(), true)
48			);
49			} else {
50			$conditions[] = sprintf(
51			'$uri == %s',
52			var_export($compiled->getPrefix(), true)
53			);
54			}
55			}
56
57			protected function conditionUriRegex(Route $route, array &$conditions)
58			{
59			$compiled = $route->getCompiled();
60
61			if ($compiled->hasUriRegex()) {
62			$conditions[] = sprintf(
63			'preg_match(%s, $uri, $uriMatch)',
64			var_export($compiled->getUriRegex(), true)
65			);
66			}
67			}
68
69			protected function conditionHttps(Route $route, array &$conditions)
70			{
71			if ($route->hasHttps()) {
72			$conditions[] = sprintf(
73			'$https === %s',
74			var_export($route->getHttps(), true)
75			);
76			}
77			}
78
79			protected function getArraysOfParameters(Route $route)
80			{
81			$arrays = [];
82			$compiled = $route->getCompiled();
83
84			$arrays[] = sprintf(
85			"['_route' => %s, '_request' => \$request]",
86			var_export($route->getName(), true)
87			);
88
89			if ($route->hasDefaults()) {
90			$arrays[] = $this->formatArray($route->getDefaults());
91			}
92
93			if ($route->hasDomain()) {
94			$arrays[] = '$domainMatch';
95			}
96			if ($compiled->hasUriRegex()) {
97			$arrays[] = '$uriMatch';
98			}
99
100			return $arrays;
101			}
102
103			protected function generateRoute(Route $route)
104			{
105			$conditions = [];
106			$this->conditionPrefix($route, $conditions);
107			$this->conditionUriRegex($route, $conditions);
108			$this->conditionHttps($route, $conditions);
109
110			$this->code->append(
111			sprintf(
112			'if (%s) {',
113			implode(' && ', $conditions)
114			)
115			);
116
117			if ($route->hasMethod()) {
118			$this->code->append(
119			sprintf(
120			'if (in_array($method, %s)) {',
121			$this->formatArray($route->getMethod())
122			)
123			);
124			}
125
126			$this->code
127			->append('return new RoutingResult(')
128			->append('true,')
129			->append('false,')
130			->append('false,')
131			->append('[],')
132			->append($this->formatArray($route->getTarget()).',');
133
134			$arrays = $this->getArraysOfParameters($route);
135			if (count($arrays) >= 2) {
136			$this->code->append(
137			sprintf(
138			'$this->filterParameters(array_replace(%s))',
139			implode(', ', $this->getArraysOfParameters($route))
140			)
141			);
142			} else {
143			$this->code->append(
144			sprintf(
145			'$this->filterParameters(%s)',
146			$this->getArraysOfParameters($route)[0]
147			)
148			);
149			}
150
151			$this->code->append(');');
152
153			if ($route->hasMethod()) {
154			$this->code->append('}');
155			$this->code->append('else {');
156			$this->code->append(
157			sprintf(
158			'$allowedMethods = array_merge($allowedMethods, %s);',
159			$this->formatArray($route->getMethod())
160			)
161			);
162			$this->code->append('}');
163			}
164
165			$this->code->append('}');
166			}
167
168			protected function generateMatchMethod()
169			{
170			$this->code
171			->append('public function match(Request $request) {')
172			->append('$uri = $request->getUri();')
173			->append('$allowedMethods = [];');
174
175			if ($this->collection->hasDomain()) {
176			$this->code->append('$domain = $request->getDomain();');
177			}
178
179			if ($this->collection->hasHttps()) {
180			$this->code->append('$https = $request->getHttps();');
181			}
182
183			if ($this->collection->hasMethod()) {
184			$this->code->append('$method = $request->getMethod();');
185			}
186
187			foreach ($this->collection->groupByDomain() as $routes) {
188			if ($routes->first()->hasDomain()) {
189			$this->code->append(
190			sprintf(
191			'if (preg_match(%s, $domain, $domainMatch)) {',
192			var_export(
193			$routes->first()->getCompiled()->getDomainRegex(),
194			true
195			)
196			)
197			);
198			}
199
200			foreach ($routes as $route) {
201			$this->generateRoute($route);
202			}
203
204			if ($routes->first()->hasDomain()) {
205			$this->code->append('}');
206			}
207			}
208
209			$this->code
210			->append('return new RoutingResult(')
211			->append('false,')
212			->append('!empty($allowedMethods),')
213			->append('empty($allowedMethods),')
214			->append('array_unique($allowedMethods),')
215			->append('[],')
216			->append('[]')
217			->append(');');
218
219			$this->code->append('}');
220			}
221
222			/**
223			* @param string $className
224			*/
225			protected function generateHeader($className)
226			{
227			$this->code->append(
228			<<<EOB
229			<?php
230			use KM\Saffron\UrlMatcher;
231			use KM\Saffron\Request;
232			use KM\Saffron\RoutingResult;
233			use KM\Saffron\UrlMatcher\Base;
234
235			class $className extends Base {
236			EOB
237			);
238			}
239
240			protected function generateFooter()
241			{
242			$this->code->append('}');
243			}
244
245			/**
246			* @param string $className
247			* @return string
248			*/
249			public function generate($className)
250			{
251			$this->generateHeader($className);
252			$this->generateMatchMethod();
253			$this->generateFooter();
254
255			return (string)$this->code;
256			}
257			}
258

krzysztof-magosa / saffron-php

GitHub Access Token became invalid

Generator::conditionUriRegex() A last analyzed 2019-10-29 21:40 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Generator::conditionUriRegex() A
last analyzed 2019-10-29 21:40 UTC