ColonyLibFactory::createColonyProductionSumReducer() - Code Metrics - Inspection of "refactor move" - st-universe/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 288b46...98b0e3 )

by Nico

created 2023-10-02 07:15 UTC

createColonyProductionSumReducer() A

↳ Parent: ColonyLibFactory

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php

declare(strict_types=1);

namespace Stu\Module\Colony\Lib;

use Doctrine\ORM\EntityManagerInterface;
use Stu\Component\Colony\ColonyFunctionManagerInterface;
use Stu\Component\Colony\ColonyPopulationCalculator;
use Stu\Component\Colony\ColonyPopulationCalculatorInterface;
use Stu\Component\Colony\Commodity\ColonyCommodityProduction;
use Stu\Component\Colony\Commodity\ColonyCommodityProductionInterface;
use Stu\Component\Colony\Commodity\ColonyProductionSumReducer;
use Stu\Component\Colony\Commodity\ColonyProductionSumReducerInterface;
use Stu\Component\Colony\Shields\ColonyShieldingManager;
use Stu\Component\Colony\Shields\ColonyShieldingManagerInterface;
use Stu\Lib\ColonyProduction\ColonyProduction;
use Stu\Lib\ModuleScreen\Addon\ModuleSelectorAddonFactoryInterface;
use Stu\Lib\ModuleScreen\ModuleSelector;
use Stu\Lib\ModuleScreen\ModuleSelectorSpecial;
use Stu\Module\Commodity\Lib\CommodityCacheInterface;
use Stu\Module\Logging\LoggerUtilFactoryInterface;
use Stu\Module\Tal\TalPageInterface;
use Stu\Orm\Entity\ColonyInterface;
use Stu\Orm\Entity\CommodityInterface;
use Stu\Orm\Entity\ShipBuildplanInterface;
use Stu\Orm\Entity\ShipInterface;
use Stu\Orm\Entity\ShipRumpInterface;
use Stu\Orm\Entity\UserInterface;
use Stu\Orm\Repository\BuildingCommodityRepositoryInterface;
use Stu\Orm\Repository\BuildingRepositoryInterface;
use Stu\Orm\Repository\ColonyRepositoryInterface;
use Stu\Orm\Repository\FlightSignatureRepositoryInterface;
use Stu\Orm\Repository\ModuleRepositoryInterface;
use Stu\Orm\Repository\PlanetFieldRepositoryInterface;
use Stu\Orm\Repository\ResearchedRepositoryInterface;
use Stu\Orm\Repository\ShipBuildplanRepositoryInterface;
use Stu\Orm\Repository\ShipRepositoryInterface;
use Stu\Orm\Repository\ShipRumpModuleLevelRepositoryInterface;
use Stu\PlanetGenerator\PlanetGeneratorInterface;

final class ColonyLibFactory implements ColonyLibFactoryInterface
{
    private PlanetFieldRepositoryInterface $planetFieldRepository;

    private BuildingRepositoryInterface $buildingRepository;

    private ColonyRepositoryInterface $colonyRepository;

    private CommodityConsumptionInterface $commodityConsumption;

    private ShipRepositoryInterface $shipRepository;

    private ShipBuildplanRepositoryInterface $shipBuildplanRepository;

    private ResearchedRepositoryInterface $researchedRepository;

    private FlightSignatureRepositoryInterface $flightSignatureRepository;

    private PlanetGeneratorInterface $planetGenerator;

    private EntityManagerInterface $entityManager;

    private BuildingCommodityRepositoryInterface $buildingCommodityRepository;

    private ModuleRepositoryInterface $moduleRepository;

    private ShipRumpModuleLevelRepositoryInterface $shipRumpModuleLevelRepository;

    private TalPageInterface $talPage;

    private PlanetFieldTypeRetrieverInterface $planetFieldTypeRetriever;

    private ColonyFunctionManagerInterface $colonyFunctionManager;

    private ModuleSelectorAddonFactoryInterface $moduleSelectorAddonFactory;

    private CommodityCacheInterface $commodityCache;

    private LoggerUtilFactoryInterface $loggerUtilFactory;

    public function __construct(
        PlanetFieldRepositoryInterface $planetFieldRepository,
        BuildingRepositoryInterface $buildingRepository,
        ColonyRepositoryInterface $colonyRepository,
        CommodityConsumptionInterface $commodityConsumption,
        ShipRepositoryInterface $shipRepository,
        ShipBuildplanRepositoryInterface $shipBuildplanRepository,
        ResearchedRepositoryInterface $researchedRepository,
        FlightSignatureRepositoryInterface $flightSignatureRepository,
        PlanetGeneratorInterface $planetGenerator,
        EntityManagerInterface $entityManager,
        BuildingCommodityRepositoryInterface $buildingCommodityRepository,
        ModuleRepositoryInterface $moduleRepository,
        ShipRumpModuleLevelRepositoryInterface $shipRumpModuleLevelRepository,
        TalPageInterface $talPage,
        PlanetFieldTypeRetrieverInterface $planetFieldTypeRetriever,
        ColonyFunctionManagerInterface $colonyFunctionManager,
        ModuleSelectorAddonFactoryInterface $moduleSelectorAddonFactory,
        CommodityCacheInterface $commodityCache,
        LoggerUtilFactoryInterface $loggerUtilFactory
    ) {
        $this->planetFieldRepository = $planetFieldRepository;
        $this->buildingRepository = $buildingRepository;
        $this->colonyRepository = $colonyRepository;
        $this->commodityConsumption = $commodityConsumption;
        $this->shipRepository = $shipRepository;
        $this->shipBuildplanRepository = $shipBuildplanRepository;
        $this->researchedRepository = $researchedRepository;
        $this->flightSignatureRepository = $flightSignatureRepository;
        $this->planetGenerator = $planetGenerator;
        $this->entityManager = $entityManager;
        $this->buildingCommodityRepository = $buildingCommodityRepository;
        $this->moduleRepository = $moduleRepository;
        $this->shipRumpModuleLevelRepository = $shipRumpModuleLevelRepository;
        $this->talPage = $talPage;
        $this->planetFieldTypeRetriever = $planetFieldTypeRetriever;
        $this->colonyFunctionManager = $colonyFunctionManager;
        $this->moduleSelectorAddonFactory = $moduleSelectorAddonFactory;
        $this->commodityCache = $commodityCache;
        $this->loggerUtilFactory = $loggerUtilFactory;
    }

    public function createBuildingFunctionTal(
        array $buildingFunctionIds
    ): BuildingFunctionTalInterface {
        return new BuildingFunctionTal($buildingFunctionIds);
    }

    public function createColonySurface(
        ColonyInterface $colony,
        ?int $buildingId = null,
        bool $showUnderground = true
    ): ColonySurfaceInterface {
        return new ColonySurface(
            $this,
            $this->planetFieldRepository,
            $this->buildingRepository,
            $this->colonyRepository,
            $this->researchedRepository,
            $this->planetGenerator,
            $this->entityManager,
            $this->loggerUtilFactory->getLoggerUtil(),
            $this->planetFieldTypeRetriever,
            $colony,
            $buildingId,
            $showUnderground
        );
    }

    public function createColonyListItem(
        ColonyInterface $colony
    ): ColonyListItemInterface {
        return new ColonyListItem(
            $this,
            $this->planetFieldRepository,
            $this->commodityConsumption,
            $colony,
            $this->flightSignatureRepository->getVisibleSignatureCount($colony)
        );
    }

    public function createBuildableRumpItem(
        ShipRumpInterface $shipRump,
        UserInterface $currentUser
    ): BuildableRumpListItemInterface {
        return new BuildableRumpListItem(
            $this->shipRepository,
            $this->shipBuildplanRepository,
            $shipRump,
            $currentUser
        );
    }

    public function createColonyProductionPreviewWrapper(
        array $production
    ): ColonyProductionPreviewWrapper {
        return new ColonyProductionPreviewWrapper(
            $this,
            $this->buildingCommodityRepository,
            $production
        );
    }

    public function createEpsProductionPreviewWrapper(
        ColonyInterface $colony
    ): ColonyEpsProductionPreviewWrapper {
        return new ColonyEpsProductionPreviewWrapper(
            $this->planetFieldRepository,
            $this->buildingRepository,
            $colony
        );
    }

    public function createModuleSelector(
        int $moduleType,
        ?ColonyInterface $colony,
        ?ShipInterface $station,
        ShipRumpInterface $rump,
        int $userId,
        ?ShipBuildplanInterface $buildplan = null
    ): ModuleSelector {

        $addon = $this->moduleSelectorAddonFactory->createModuleSelectorAddon($moduleType);

        return new ModuleSelector(
            $this->moduleRepository,
            $this->shipRumpModuleLevelRepository,
            $this->talPage,
            $moduleType,
            $colony,
            $station,
            $rump,
            $userId,
            $addon,
            $buildplan
        );
    }

    public function createModuleSelectorSpecial(
        int $moduleType,
        ?ColonyInterface $colony,
        ?ShipInterface $station,
        ShipRumpInterface $rump,
        int $userId,
        ?ShipBuildplanInterface $buildplan = null
    ): ModuleSelectorSpecial {
        return new ModuleSelectorSpecial(
            $this->moduleRepository,
            $this->shipRumpModuleLevelRepository,
            $this->talPage,
            $moduleType,
            $colony,
            $station,
            $rump,
            $userId,
            null,
            $buildplan
        );
    }

    public function createColonyProduction(
        CommodityInterface $commodity,
        int $production,
        ?int $pc = null
    ): ColonyProduction {
        return new ColonyProduction(
            $commodity,
            $production,
            $pc
        );
    }

    public function createColonyShieldingManager(
        ColonyInterface $colony
    ): ColonyShieldingManagerInterface {
        return new ColonyShieldingManager(
            $this->planetFieldRepository,
            $this->colonyFunctionManager,
            $colony
        );
    }

    public function createColonyCommodityProduction(
        ColonyInterface $colony
    ): ColonyCommodityProductionInterface {
        return new ColonyCommodityProduction(
            $this->buildingCommodityRepository,
            $colony,
            $this,
            $this->commodityCache
        );
    }

    public function createColonyProductionSumReducer(): ColonyProductionSumReducerInterface
    {
        return new ColonyProductionSumReducer();
    }

    public function createColonyPopulationCalculator(
        ColonyInterface $colony,
        array $production = null
    ): ColonyPopulationCalculatorInterface {

        return new ColonyPopulationCalculator(
            $colony,
            $production ?? $this->createColonyCommodityProduction($colony)->getProduction()
        );
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Stu\Module\Colony\Lib;
6
7		use Doctrine\ORM\EntityManagerInterface;
8		use Stu\Component\Colony\ColonyFunctionManagerInterface;
9		use Stu\Component\Colony\ColonyPopulationCalculator;
10		use Stu\Component\Colony\ColonyPopulationCalculatorInterface;
11		use Stu\Component\Colony\Commodity\ColonyCommodityProduction;
12		use Stu\Component\Colony\Commodity\ColonyCommodityProductionInterface;
13		use Stu\Component\Colony\Commodity\ColonyProductionSumReducer;
14		use Stu\Component\Colony\Commodity\ColonyProductionSumReducerInterface;
15		use Stu\Component\Colony\Shields\ColonyShieldingManager;
16		use Stu\Component\Colony\Shields\ColonyShieldingManagerInterface;
17		use Stu\Lib\ColonyProduction\ColonyProduction;
18		use Stu\Lib\ModuleScreen\Addon\ModuleSelectorAddonFactoryInterface;
19		use Stu\Lib\ModuleScreen\ModuleSelector;
20		use Stu\Lib\ModuleScreen\ModuleSelectorSpecial;
21		use Stu\Module\Commodity\Lib\CommodityCacheInterface;
22		use Stu\Module\Logging\LoggerUtilFactoryInterface;
23		use Stu\Module\Tal\TalPageInterface;
24		use Stu\Orm\Entity\ColonyInterface;
25		use Stu\Orm\Entity\CommodityInterface;
26		use Stu\Orm\Entity\ShipBuildplanInterface;
27		use Stu\Orm\Entity\ShipInterface;
28		use Stu\Orm\Entity\ShipRumpInterface;
29		use Stu\Orm\Entity\UserInterface;
30		use Stu\Orm\Repository\BuildingCommodityRepositoryInterface;
31		use Stu\Orm\Repository\BuildingRepositoryInterface;
32		use Stu\Orm\Repository\ColonyRepositoryInterface;
33		use Stu\Orm\Repository\FlightSignatureRepositoryInterface;
34		use Stu\Orm\Repository\ModuleRepositoryInterface;
35		use Stu\Orm\Repository\PlanetFieldRepositoryInterface;
36		use Stu\Orm\Repository\ResearchedRepositoryInterface;
37		use Stu\Orm\Repository\ShipBuildplanRepositoryInterface;
38		use Stu\Orm\Repository\ShipRepositoryInterface;
39		use Stu\Orm\Repository\ShipRumpModuleLevelRepositoryInterface;
40		use Stu\PlanetGenerator\PlanetGeneratorInterface;
41
42		final class ColonyLibFactory implements ColonyLibFactoryInterface
43		{
44		private PlanetFieldRepositoryInterface $planetFieldRepository;
45
46		private BuildingRepositoryInterface $buildingRepository;
47
48		private ColonyRepositoryInterface $colonyRepository;
49
50		private CommodityConsumptionInterface $commodityConsumption;
51
52		private ShipRepositoryInterface $shipRepository;
53
54		private ShipBuildplanRepositoryInterface $shipBuildplanRepository;
55
56		private ResearchedRepositoryInterface $researchedRepository;
57
58		private FlightSignatureRepositoryInterface $flightSignatureRepository;
59
60		private PlanetGeneratorInterface $planetGenerator;
61
62		private EntityManagerInterface $entityManager;
63
64		private BuildingCommodityRepositoryInterface $buildingCommodityRepository;
65
66		private ModuleRepositoryInterface $moduleRepository;
67
68		private ShipRumpModuleLevelRepositoryInterface $shipRumpModuleLevelRepository;
69
70		private TalPageInterface $talPage;
71
72		private PlanetFieldTypeRetrieverInterface $planetFieldTypeRetriever;
73
74		private ColonyFunctionManagerInterface $colonyFunctionManager;
75
76		private ModuleSelectorAddonFactoryInterface $moduleSelectorAddonFactory;
77
78		private CommodityCacheInterface $commodityCache;
79
80		private LoggerUtilFactoryInterface $loggerUtilFactory;
81
82	2	public function __construct(
83		PlanetFieldRepositoryInterface $planetFieldRepository,
84		BuildingRepositoryInterface $buildingRepository,
85		ColonyRepositoryInterface $colonyRepository,
86		CommodityConsumptionInterface $commodityConsumption,
87		ShipRepositoryInterface $shipRepository,
88		ShipBuildplanRepositoryInterface $shipBuildplanRepository,
89		ResearchedRepositoryInterface $researchedRepository,
90		FlightSignatureRepositoryInterface $flightSignatureRepository,
91		PlanetGeneratorInterface $planetGenerator,
92		EntityManagerInterface $entityManager,
93		BuildingCommodityRepositoryInterface $buildingCommodityRepository,
94		ModuleRepositoryInterface $moduleRepository,
95		ShipRumpModuleLevelRepositoryInterface $shipRumpModuleLevelRepository,
96		TalPageInterface $talPage,
97		PlanetFieldTypeRetrieverInterface $planetFieldTypeRetriever,
98		ColonyFunctionManagerInterface $colonyFunctionManager,
99		ModuleSelectorAddonFactoryInterface $moduleSelectorAddonFactory,
100		CommodityCacheInterface $commodityCache,
101		LoggerUtilFactoryInterface $loggerUtilFactory
102		) {
103	2	$this->planetFieldRepository = $planetFieldRepository;
104	2	$this->buildingRepository = $buildingRepository;
105	2	$this->colonyRepository = $colonyRepository;
106	2	$this->commodityConsumption = $commodityConsumption;
107	2	$this->shipRepository = $shipRepository;
108	2	$this->shipBuildplanRepository = $shipBuildplanRepository;
109	2	$this->researchedRepository = $researchedRepository;
110	2	$this->flightSignatureRepository = $flightSignatureRepository;
111	2	$this->planetGenerator = $planetGenerator;
112	2	$this->entityManager = $entityManager;
113	2	$this->buildingCommodityRepository = $buildingCommodityRepository;
114	2	$this->moduleRepository = $moduleRepository;
115	2	$this->shipRumpModuleLevelRepository = $shipRumpModuleLevelRepository;
116	2	$this->talPage = $talPage;
117	2	$this->planetFieldTypeRetriever = $planetFieldTypeRetriever;
118	2	$this->colonyFunctionManager = $colonyFunctionManager;
119	2	$this->moduleSelectorAddonFactory = $moduleSelectorAddonFactory;
120	2	$this->commodityCache = $commodityCache;
121	2	$this->loggerUtilFactory = $loggerUtilFactory;
122		}
123
124		public function createBuildingFunctionTal(
125		array $buildingFunctionIds
126		): BuildingFunctionTalInterface {
127		return new BuildingFunctionTal($buildingFunctionIds);
128		}
129
130		public function createColonySurface(
131		ColonyInterface $colony,
132		?int $buildingId = null,
133		bool $showUnderground = true
134		): ColonySurfaceInterface {
135		return new ColonySurface(
136		$this,
137		$this->planetFieldRepository,
138		$this->buildingRepository,
139		$this->colonyRepository,
140		$this->researchedRepository,
141		$this->planetGenerator,
142		$this->entityManager,
143		$this->loggerUtilFactory->getLoggerUtil(),
144		$this->planetFieldTypeRetriever,
145		$colony,
146		$buildingId,
147		$showUnderground
148		);
149		}
150
151		public function createColonyListItem(
152		ColonyInterface $colony
153		): ColonyListItemInterface {
154		return new ColonyListItem(
155		$this,
156		$this->planetFieldRepository,
157		$this->commodityConsumption,
158		$colony,
159		$this->flightSignatureRepository->getVisibleSignatureCount($colony)
160		);
161		}
162
163		public function createBuildableRumpItem(
164		ShipRumpInterface $shipRump,
165		UserInterface $currentUser
166		): BuildableRumpListItemInterface {
167		return new BuildableRumpListItem(
168		$this->shipRepository,
169		$this->shipBuildplanRepository,
170		$shipRump,
171		$currentUser
172		);
173		}
174
175		public function createColonyProductionPreviewWrapper(
176		array $production
177		): ColonyProductionPreviewWrapper {
178		return new ColonyProductionPreviewWrapper(
179		$this,
180		$this->buildingCommodityRepository,
181		$production
182		);
183		}
184
185		public function createEpsProductionPreviewWrapper(
186		ColonyInterface $colony
187		): ColonyEpsProductionPreviewWrapper {
188		return new ColonyEpsProductionPreviewWrapper(
189		$this->planetFieldRepository,
190		$this->buildingRepository,
191		$colony
192		);
193		}
194
195		public function createModuleSelector(
196		int $moduleType,
197		?ColonyInterface $colony,
198		?ShipInterface $station,
199		ShipRumpInterface $rump,
200		int $userId,
201		?ShipBuildplanInterface $buildplan = null
202		): ModuleSelector {
203
204		$addon = $this->moduleSelectorAddonFactory->createModuleSelectorAddon($moduleType);
205
206		return new ModuleSelector(
207		$this->moduleRepository,
208		$this->shipRumpModuleLevelRepository,
209		$this->talPage,
210		$moduleType,
211		$colony,
212		$station,
213		$rump,
214		$userId,
215		$addon,
216		$buildplan
217		);
218		}
219
220		public function createModuleSelectorSpecial(
221		int $moduleType,
222		?ColonyInterface $colony,
223		?ShipInterface $station,
224		ShipRumpInterface $rump,
225		int $userId,
226		?ShipBuildplanInterface $buildplan = null
227		): ModuleSelectorSpecial {
228		return new ModuleSelectorSpecial(
229		$this->moduleRepository,
230		$this->shipRumpModuleLevelRepository,
231		$this->talPage,
232		$moduleType,
233		$colony,
234		$station,
235		$rump,
236		$userId,
237		null,
238		$buildplan
239		);
240		}
241
242		public function createColonyProduction(
243		CommodityInterface $commodity,
244		int $production,
245		?int $pc = null
246		): ColonyProduction {
247		return new ColonyProduction(
248		$commodity,
249		$production,
250		$pc
251		);
252		}
253
254		public function createColonyShieldingManager(
255		ColonyInterface $colony
256		): ColonyShieldingManagerInterface {
257		return new ColonyShieldingManager(
258		$this->planetFieldRepository,
259		$this->colonyFunctionManager,
260		$colony
261		);
262		}
263
264		public function createColonyCommodityProduction(
265		ColonyInterface $colony
266		): ColonyCommodityProductionInterface {
267		return new ColonyCommodityProduction(
268		$this->buildingCommodityRepository,
269		$colony,
270		$this,
271		$this->commodityCache
272		);
273		}
274
275		public function createColonyProductionSumReducer(): ColonyProductionSumReducerInterface
276		{
277		return new ColonyProductionSumReducer();
278		}
279
280		public function createColonyPopulationCalculator(
281		ColonyInterface $colony,
282		array $production = null
283		): ColonyPopulationCalculatorInterface {
284
285		return new ColonyPopulationCalculator(
286		$colony,
287		$production ?? $this->createColonyCommodityProduction($colony)->getProduction()
288		);
289		}
290		}
291

st-universe / core

Push — master ( 288b46...98b0e3 )

createColonyProductionSumReducer() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like