RouterEventManager::wrapCallbacksForIgnore() - Code Metrics - Inspection of "refactoring the code" - imanghafoori1/laravel-heyman - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 153345...f1eae3 )

by Iman

created 2018-08-03 15:29 UTC

RouterEventManager::wrapCallbacksForIgnore() A

↳ Parent: RouterEventManager

Complexity

Conditions	2
Paths	1

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2

Importance

Changes

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

<?php

namespace Imanghafoori\HeyMan\WatchingStrategies;

use Illuminate\Support\Str;

class RouterEventManager
{
    private $target;

    private $value;

    private $all = [];

    /**
     * RouterEventManager constructor.
     *
     * @param $target
     * @param $value
     *
     * @return \Imanghafoori\HeyMan\WatchingStrategies\RouterEventManager
     */
    public function init($target, $value)
    {
        $this->target = $target;
        $this->value = $value;

        return $this;
    }

    /**
     * @param $callback
     */
    public function startGuarding(callable $callback)
    {
        foreach ($this->value as $value) {
            $this->all[$value][] = [$this->target, $callback];
        }
    }

    /**
     * @param $action
     *
     * @return array
     */
    public function resolveCallbacks($action): array
    {
        if (array_key_exists($action, $this->all)) {
            $callbacks = $this->all[$action];

            return $this->wrapCallbacksForIgnore($callbacks);
        }

        foreach ($this->all as $pattern => $callbacks) {
            if (Str::is($pattern, $action)) {
                return $this->wrapCallbacksForIgnore($callbacks);
            }
        }

        return [function () {
        }];
    }

    /**
     * @param $callbacks
     *
     * @return array
     */
    private function wrapCallbacksForIgnore($callbacks): array
    {
        return array_map(function ($callback) {
            $c = $callback[1];
            return function () use ($c) {
                if (!config('heyman_ignore_route', false)) {
                    $c();
                }
            };
        }, $callbacks);
    }
}


1		<?php
2
3		namespace Imanghafoori\HeyMan\WatchingStrategies;
4
5		use Illuminate\Support\Str;
6
7		class RouterEventManager
8		{
9		private $target;
10
11		private $value;
12
13		private $all = [];
14
15		/**
16		* RouterEventManager constructor.
17		*
18		* @param $target
19		* @param $value
20		*
21		* @return \Imanghafoori\HeyMan\WatchingStrategies\RouterEventManager
22		*/
23		public function init($target, $value)
24		{
25		$this->target = $target;
26		$this->value = $value;
27	54
28		return $this;
29	54	}
30	54
31		/**
32	54	* @param $callback
33		*/
34		public function startGuarding(callable $callback)
35	44	{
36		foreach ($this->value as $value) {
37	44	$this->all[$value][] = [$this->target, $callback];
38		}
39		}
40	28
41		/**
42	28	* @param $action
43		*
44		* @return array
45	26	*/
46		public function resolveCallbacks($action): array
47	26	{
48		if (array_key_exists($action, $this->all)) {
49		$callbacks = $this->all[$action];
50
51		return $this->wrapCallbacksForIgnore($callbacks);
52		}
53	46
54		foreach ($this->all as $pattern => $callbacks) {
55	46	if (Str::is($pattern, $action)) {
56	46	return $this->wrapCallbacksForIgnore($callbacks);
57		}
58	46	}
59
60		return [function () {
61		}];
62		}
63
64		/**
65		* @param $callbacks
66	44	*
67		* @return array
68	44	*/
69	35	private function wrapCallbacksForIgnore($callbacks): array
70		{
71	35	return array_map(function ($callback) {
72		$c = $callback[1];
73		return function () use ($c) {
74	29	if (!config('heyman_ignore_route', false)) {
75	11	$c();
76	11	}
77		};
78		}, $callbacks);
79		}
80		}
81

imanghafoori1 / laravel-heyman

Push — master ( 153345...f1eae3 )

RouterEventManager::wrapCallbacksForIgnore() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like