RuleHelper::__construct() - Code Metrics - Inspection of "Removing flex ..." - obblm/core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — v1.x-dev (5736e4)

by Benjamin

created 2020-10-02 00:32 UTC

RuleHelper::__construct() A

↳ Parent: RuleHelper

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace Obblm\Core\Helper;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\ORM\EntityManagerInterface;
use Exception;
use Obblm\Core\Contracts\RuleHelperInterface;
use Obblm\Core\Entity\Rule;
use Obblm\Core\Event\RulesCollectorEvent;
use Obblm\Core\Exception\UnexpectedTypeException;
use Obblm\Core\Form\Player\ActionBb2020Type;
use Obblm\Core\Form\Player\ActionType;
use Obblm\Core\Form\Player\InjuryBb2020Type;
use Obblm\Core\Form\Player\InjuryType;
use Obblm\Core\Helper\Rule\CanHaveRuleInterface;
use Psr\Cache\InvalidArgumentException;
use Symfony\Component\Cache\Adapter\AdapterInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;

class RuleHelper
{
    const CACHE_GLUE = '.';

    private $helpers;
    private $em;
    private $dispatcher;
    private $rules;
    private $cacheAdapter;

    public function __construct(AdapterInterface $adapter, EntityManagerInterface $em, EventDispatcherInterface $dispatcher)
    {
        $this->helpers = new ArrayCollection();
        $this->em = $em;
        $this->dispatcher = $dispatcher;
        $this->cacheAdapter = $adapter;
        $this->rules = new ArrayCollection();
    }

    /**
     * @return ArrayCollection
     */
    public function getRules():ArrayCollection
    {
        return $this->rules;
    }

    /**
     * @param Rule|CanHaveRuleInterface $item
     * @return $this
     */
    public function addRule($item): self
    {
        if (!$this->rules->contains($item)) {
            $this->rules[] = $item;
        }

        return $this;
    }
    /**
     * @param Rule|CanHaveRuleInterface $item
     * @return $this
     */
    public function removeRule($item): self
    {
        if ($this->rules->contains($item)) {
            $this->rules->removeElement($item);
        }
        return $this;
    }

    /**
     * @param RuleHelperInterface $helper
     */
    public function addHelper(RuleHelperInterface $helper)
    {
        $this->helpers->offsetSet($helper->getKey(), $helper);
    }

    /**
     * @return ArrayCollection|Rule[]|object[]
     */
    public function getRuleChoices()
    {
        $rules = $this->em->getRepository(Rule::class)->findAll();

        $this->rules = (!$rules instanceof ArrayCollection) ? new ArrayCollection($rules) : $rules;

        $collector = new RulesCollectorEvent($this);
        $this->dispatcher->dispatch($collector, RulesCollectorEvent::COLLECT);
        return $this->rules;
    }

    /**
     * @return Rule[]|object[]
     */
    public function getRulesAvailableForTeamCreation()
    {
        return $this->em->getRepository(Rule::class)->findAll();
    }

    /**
     * @param Rule $object
     * @return array
     */
    public static function getAvailableRosters(Rule $object):array
    {
        $rule = $object->getRule();
        return array_keys($rule['rosters']);
    }

    /**
     * @param Rule $rule
     * @return string
     */
    public static function getActionFormType(Rule $rule):string
    {
        return ($rule->isPostBb2020()) ? ActionBb2020Type::class : ActionType::class;
    }

    /**
     * @param Rule $rule
     * @return string
     */
    public static function getInjuryFormType(Rule $rule):string
    {
        return ($rule->isPostBb2020()) ? InjuryBb2020Type::class : InjuryType::class;
    }

    /****************
     * CACHE METHODS
     ***************/

    /**
     * @param $item
     * @return RuleHelperInterface
     * @throws \Psr\Cache\InvalidArgumentException
     */
    public function getHelper($item):RuleHelperInterface
    {
        if ($item instanceof CanHaveRuleInterface) {
            $rule = $item->getRule();
        } else {
            $rule = $item;
        }
        $key = $this->getCacheKey($rule);
        return $this->getCacheOrCreate($key, $rule);
    }

    /**
     * @param $key
     * @param Rule $rule
     * @return RuleHelperInterface
     * @throws InvalidArgumentException
     */
    public function getCacheOrCreate($key, Rule $rule):RuleHelperInterface
    {
        try {
            $item = $this->cacheAdapter->getItem($key);
            if (!$item->isHit()) {
                $helper = $this->getNotCachedHelper($rule->getRuleKey());
                $helper->attachRule($rule);
                $this->cacheAdapter->save($item->set([
                    'class' => get_class($helper) . '::class',
                    'helper' => $helper
                ]));
            } else {
                $normalizedRule = $item->get();
                $helper = $normalizedRule['helper'];
            }
        } catch (InvalidArgumentException $e) {
            $helper = $this->getNotCachedHelper($rule->getRuleKey());
            $helper->attachRule($rule);
        }

        return $helper;
    }

    /**
     * @param $key
     * @return RuleHelperInterface|null
     * @throws Exception
     */
    private function getNotCachedHelper($key):?RuleHelperInterface
    {
        if (!isset($this->helpers[$key])) {
            throw new Exception('No RuleHelperInterface found for ' . $key);
        }
        return $this->helpers[$key];
    }

    /**
     * @param Rule $rule
     * @return string
     */
    protected static function getCacheKey(Rule $rule)
    {
        return join(self::CACHE_GLUE, ['obblm', 'rules', $rule->getRuleKey(), $rule->getId()]);
    }
}


1		<?php
2
3		namespace Obblm\Core\Helper;
4
5		use Doctrine\Common\Collections\ArrayCollection;
6		use Doctrine\ORM\EntityManagerInterface;
7		use Exception;
8		use Obblm\Core\Contracts\RuleHelperInterface;
9		use Obblm\Core\Entity\Rule;
10		use Obblm\Core\Event\RulesCollectorEvent;
11		use Obblm\Core\Exception\UnexpectedTypeException;
12		use Obblm\Core\Form\Player\ActionBb2020Type;
13		use Obblm\Core\Form\Player\ActionType;
14		use Obblm\Core\Form\Player\InjuryBb2020Type;
15		use Obblm\Core\Form\Player\InjuryType;
16		use Obblm\Core\Helper\Rule\CanHaveRuleInterface;
17		use Psr\Cache\InvalidArgumentException;
18		use Symfony\Component\Cache\Adapter\AdapterInterface;
19		use Symfony\Component\EventDispatcher\EventDispatcherInterface;
20
21		class RuleHelper
22		{
23		const CACHE_GLUE = '.';
24
25		private $helpers;
26		private $em;
27		private $dispatcher;
28		private $rules;
29		private $cacheAdapter;
30
31	2	public function __construct(AdapterInterface $adapter, EntityManagerInterface $em, EventDispatcherInterface $dispatcher)
32		{
33	2	$this->helpers = new ArrayCollection();
34	2	$this->em = $em;
35	2	$this->dispatcher = $dispatcher;
36	2	$this->cacheAdapter = $adapter;
37	2	$this->rules = new ArrayCollection();
38	2	}
39
40		/**
41		* @return ArrayCollection
42		*/
43		public function getRules():ArrayCollection
44		{
45		return $this->rules;
46		}
47
48		/**
49		* @param Rule\|CanHaveRuleInterface $item
50		* @return $this
51		*/
52	2	public function addRule($item): self
53		{
54	2	if (!$this->rules->contains($item)) {
55	2	$this->rules[] = $item;
56		}
57
58	2	return $this;
59		}
60		/**
61		* @param Rule\|CanHaveRuleInterface $item
62		* @return $this
63		*/
64		public function removeRule($item): self
65		{
66		if ($this->rules->contains($item)) {
67		$this->rules->removeElement($item);
68		}
69		return $this;
70		}
71
72		/**
73		* @param RuleHelperInterface $helper
74		*/
75	2	public function addHelper(RuleHelperInterface $helper)
76		{
77	2	$this->helpers->offsetSet($helper->getKey(), $helper);
78	2	}
79
80		/**
81		* @return ArrayCollection\|Rule[]\|object[]
82		*/
83		public function getRuleChoices()
84		{
85		$rules = $this->em->getRepository(Rule::class)->findAll();
86
87		$this->rules = (!$rules instanceof ArrayCollection) ? new ArrayCollection($rules) : $rules;
88
89		$collector = new RulesCollectorEvent($this);
90		$this->dispatcher->dispatch($collector, RulesCollectorEvent::COLLECT);
91		return $this->rules;
92		}
93
94		/**
95		* @return Rule[]\|object[]
96		*/
97		public function getRulesAvailableForTeamCreation()
98		{
99		return $this->em->getRepository(Rule::class)->findAll();
100		}
101
102		/**
103		* @param Rule $object
104		* @return array
105		*/
106		public static function getAvailableRosters(Rule $object):array
107		{
108		$rule = $object->getRule();
109		return array_keys($rule['rosters']);
110		}
111
112		/**
113		* @param Rule $rule
114		* @return string
115		*/
116		public static function getActionFormType(Rule $rule):string
117		{
118		return ($rule->isPostBb2020()) ? ActionBb2020Type::class : ActionType::class;
119		}
120
121		/**
122		* @param Rule $rule
123		* @return string
124		*/
125		public static function getInjuryFormType(Rule $rule):string
126		{
127		return ($rule->isPostBb2020()) ? InjuryBb2020Type::class : InjuryType::class;
128		}
129
130		/****************
131		* CACHE METHODS
132		***************/
133
134		/**
135		* @param $item
136		* @return RuleHelperInterface
137		* @throws \Psr\Cache\InvalidArgumentException
138		*/
139	2	public function getHelper($item):RuleHelperInterface
140		{
141	2	if ($item instanceof CanHaveRuleInterface) {
142		$rule = $item->getRule();
143		} else {
144	2	$rule = $item;
145		}
146	2	$key = $this->getCacheKey($rule);
147	2	return $this->getCacheOrCreate($key, $rule);
148		}
149
150		/**
151		* @param $key
152		* @param Rule $rule
153		* @return RuleHelperInterface
154		* @throws InvalidArgumentException
155		*/
156	2	public function getCacheOrCreate($key, Rule $rule):RuleHelperInterface
157		{
158		try {
159	2	$item = $this->cacheAdapter->getItem($key);
160	2	if (!$item->isHit()) {
161	2	$helper = $this->getNotCachedHelper($rule->getRuleKey());
162	1	$helper->attachRule($rule);
163	1	$this->cacheAdapter->save($item->set([
164	1	'class' => get_class($helper) . '::class',
165	1	'helper' => $helper
166		]));
167		} else {
168	1	$normalizedRule = $item->get();
169	1	$helper = $normalizedRule['helper'];
170		}
171	1	} catch (InvalidArgumentException $e) {
172		$helper = $this->getNotCachedHelper($rule->getRuleKey());
173		$helper->attachRule($rule);
174		}
175
176	1	return $helper;
177		}
178
179		/**
180		* @param $key
181		* @return RuleHelperInterface\|null
182		* @throws Exception
183		*/
184	2	private function getNotCachedHelper($key):?RuleHelperInterface
185		{
186	2	if (!isset($this->helpers[$key])) {
187	1	throw new Exception('No RuleHelperInterface found for ' . $key);
188		}
189	1	return $this->helpers[$key];
190		}
191
192		/**
193		* @param Rule $rule
194		* @return string
195		*/
196	2	protected static function getCacheKey(Rule $rule)
197		{
198	2	return join(self::CACHE_GLUE, ['obblm', 'rules', $rule->getRuleKey(), $rule->getId()]);
199		}
200		}
201

obblm / core

Branch — v1.x-dev (5736e4)

RuleHelper::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like