StorageService::__construct() - Code Metrics - php-translation/symfony-bundle - Measure and Improve Code Quality continuously with Scrutinizer

StorageService::__construct() A
last analyzed 2021-03-26 16:59 UTC

↳ Parent: StorageService

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	2
Bugs	0	Features	0

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

<?php

/*
 * This file is part of the PHP Translation package.
 *
 * (c) PHP Translation team <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Translation\Bundle\Service;

use Symfony\Component\Translation\MessageCatalogue;
use Translation\Bundle\Catalogue\CatalogueFetcher;
use Translation\Bundle\Model\Configuration;
use Translation\Common\Exception\LogicException;
use Translation\Common\Model\Message;
use Translation\Common\Model\MessageInterface;
use Translation\Common\Storage;
use Translation\Common\TransferableStorage;

/**
 * A service that you use to handle the storages.
 *
 * @author Tobias Nyholm <[email protected]>
 */
final class StorageService implements Storage
{
    const DIRECTION_UP = 'up';

    const DIRECTION_DOWN = 'down';

    /**
     * @var Storage[]
     */
    private $localStorages = [];

    /**
     * @var Storage[]
     */
    private $remoteStorages = [];

    private $catalogueFetcher;
    private $config;

    public function __construct(CatalogueFetcher $catalogueFetcher, Configuration $config)
    {
        $this->catalogueFetcher = $catalogueFetcher;
        $this->config = $config;
    }

    /**
     * Download catalogues from all storages.
     *
     * @return MessageCatalogue[]
     */
    public function download(array $exportOptions = []): array
    {
        $catalogues = [];
        foreach ($this->config->getLocales() as $locale) {
            $catalogues[$locale] = new MessageCatalogue($locale);
            foreach ($this->remoteStorages as $storage) {
                if ($storage instanceof TransferableStorage) {
                    $storage->export($catalogues[$locale], $exportOptions);
                }
            }
        }

        return $catalogues;
    }

    /**
     * Synchronize translations with remote.
     */
    public function sync(string $direction = self::DIRECTION_DOWN, array $importOptions = [], array $exportOptions = []): void
    {
        switch ($direction) {
            case self::DIRECTION_DOWN:
                $this->mergeDown($exportOptions);
                $this->mergeUp($importOptions);

                break;
            case self::DIRECTION_UP:
                $this->mergeUp($importOptions);
                $this->mergeDown($exportOptions);

                break;
            default:
                throw new LogicException(\sprintf('Direction must be either "up" or "down". Value "%s" was provided', $direction));
        }
    }

    /**
     * Download and merge all translations from remote storages down to your local storages.
     * Only the local storages will be changed.
     */
    public function mergeDown(array $exportOptions = []): void
    {
        $catalogues = $this->download($exportOptions);

        foreach ($catalogues as $locale => $catalogue) {
            foreach ($catalogue->all() as $domain => $messages) {
                foreach ($messages as $key => $translation) {
                    $message = new Message($key, $domain, $locale, $translation);
                    $this->updateStorages($this->localStorages, $message);
                }
            }
        }
    }

    /**
     * Upload and merge all translations from local storages up to your remote storages.
     * Only the remote storages will be changed.
     *
     * This will overwrite your remote copy.
     */
    public function mergeUp(array $importOptions = []): void
    {
        $catalogues = $this->catalogueFetcher->getCatalogues($this->config);
        foreach ($catalogues as $catalogue) {
            foreach ($this->remoteStorages as $storage) {
                if ($storage instanceof TransferableStorage) {
                    $storage->import($catalogue, $importOptions);
                }
            }
        }
    }

    /**
     * Get the very latest version we know of a message. First look at the remote storage
     * fall back on the local ones.
     */
    public function syncAndFetchMessage(string $locale, string $domain, string $key): ?Message
    {
        if (null === $message = $this->getFromStorages($this->remoteStorages, $locale, $domain, $key)) {
            // If message is not in remote storages, try local
            $message = $this->getFromStorages($this->localStorages, $locale, $domain, $key);
        }

        if (!$message) {

            return null;
        }

        $this->updateStorages($this->localStorages, $message);

        return $message;
    }

    /**
     * Try to get a translation from all the storages, start looking in the first
     * local storage and then move on to the remote storages.
     * {@inheritdoc}
     */
    public function get(string $locale, string $domain, string $key): ?MessageInterface
    {
        foreach ([$this->localStorages, $this->remoteStorages] as $storages) {
            $value = $this->getFromStorages($storages, $locale, $domain, $key);
            if (null !== $value) {
                return $value;
            }
        }

        return null;
    }

    /**
     * @param Storage[] $storages
     */
    private function getFromStorages(array $storages, string $locale, string $domain, string $key): ?Message
    {
        foreach ($storages as $storage) {
            $value = $storage->get($locale, $domain, $key);
            if (null !== $value) {
                return $value;

            }
        }

        return null;
    }

    /**
     * Create all configured storages with this message. This will not overwrite
     * existing message.
     *
     * {@inheritdoc}
     */
    public function create(MessageInterface $message): void
    {
        // Validate if message actually has data
        if (empty((array) $message)) {
            return;
        }

        foreach ([$this->localStorages, $this->remoteStorages] as $storages) {
            /** @var Storage $storage */
            foreach ($storages as $storage) {
                $storage->create($message);
            }
        }
    }

    /**
     * Update all configured storages with this message. If messages does not exist
     * it will be created.
     *
     * {@inheritdoc}
     */
    public function update(MessageInterface $message): void
    {
        foreach ([$this->localStorages, $this->remoteStorages] as $storages) {
            $this->updateStorages($storages, $message);
        }
    }

    /**
     * @param Storage[] $storages
     */
    private function updateStorages(array $storages, MessageInterface $message): void
    {
        // Validate if message actually has data
        if (empty((array) $message)) {
            return;
        }

        foreach ($storages as $storage) {
            $storage->update($message);
        }
    }

    /**
     * Delete the message form all storages.
     *
     * {@inheritdoc}
     */
    public function delete(string $locale, string $domain, string $key): void
    {
        foreach ([$this->localStorages, $this->remoteStorages] as $storages) {
            /** @var Storage $storage */
            foreach ($storages as $storage) {
                $storage->delete($locale, $domain, $key);
            }
        }
    }

    public function addLocalStorage(Storage $localStorage): self
    {
        $this->localStorages[] = $localStorage;

        return $this;
    }

    public function addRemoteStorage(Storage $remoteStorage): self
    {
        $this->remoteStorages[] = $remoteStorage;

        return $this;
    }
}


1			<?php
2
3			/*
4			* This file is part of the PHP Translation package.
5			*
6			* (c) PHP Translation team <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Translation\Bundle\Service;
13
14			use Symfony\Component\Translation\MessageCatalogue;
15			use Translation\Bundle\Catalogue\CatalogueFetcher;
16			use Translation\Bundle\Model\Configuration;
17			use Translation\Common\Exception\LogicException;
18			use Translation\Common\Model\Message;
19			use Translation\Common\Model\MessageInterface;
20			use Translation\Common\Storage;
21			use Translation\Common\TransferableStorage;
22
23			/**
24			* A service that you use to handle the storages.
25			*
26			* @author Tobias Nyholm <[email protected]>
27			*/
28			final class StorageService implements Storage
29			{
30			const DIRECTION_UP = 'up';
31
32			const DIRECTION_DOWN = 'down';
33
34			/**
35			* @var Storage[]
36			*/
37			private $localStorages = [];
38
39			/**
40			* @var Storage[]
41			*/
42			private $remoteStorages = [];
43
44			private $catalogueFetcher;
45			private $config;
46
47			public function __construct(CatalogueFetcher $catalogueFetcher, Configuration $config)
48			{
49			$this->catalogueFetcher = $catalogueFetcher;
50			$this->config = $config;
51			}
52
53			/**
54			* Download catalogues from all storages.
55			*
56			* @return MessageCatalogue[]
57			*/
58			public function download(array $exportOptions = []): array
59			{
60			$catalogues = [];
61			foreach ($this->config->getLocales() as $locale) {
62			$catalogues[$locale] = new MessageCatalogue($locale);
63			foreach ($this->remoteStorages as $storage) {
64			if ($storage instanceof TransferableStorage) {
65			$storage->export($catalogues[$locale], $exportOptions);
66			}
67			}
68			}
69
70			return $catalogues;
71			}
72
73			/**
74			* Synchronize translations with remote.
75			*/
76			public function sync(string $direction = self::DIRECTION_DOWN, array $importOptions = [], array $exportOptions = []): void
77			{
78			switch ($direction) {
79			case self::DIRECTION_DOWN:
80			$this->mergeDown($exportOptions);
81			$this->mergeUp($importOptions);
82
83			break;
84			case self::DIRECTION_UP:
85			$this->mergeUp($importOptions);
86			$this->mergeDown($exportOptions);
87
88			break;
89			default:
90			throw new LogicException(\sprintf('Direction must be either "up" or "down". Value "%s" was provided', $direction));
91			}
92			}
93
94			/**
95			* Download and merge all translations from remote storages down to your local storages.
96			* Only the local storages will be changed.
97			*/
98			public function mergeDown(array $exportOptions = []): void
99			{
100			$catalogues = $this->download($exportOptions);
101
102			foreach ($catalogues as $locale => $catalogue) {
103			foreach ($catalogue->all() as $domain => $messages) {
104			foreach ($messages as $key => $translation) {
105			$message = new Message($key, $domain, $locale, $translation);
106			$this->updateStorages($this->localStorages, $message);
107			}
108			}
109			}
110			}
111
112			/**
113			* Upload and merge all translations from local storages up to your remote storages.
114			* Only the remote storages will be changed.
115			*
116			* This will overwrite your remote copy.
117			*/
118			public function mergeUp(array $importOptions = []): void
119			{
120			$catalogues = $this->catalogueFetcher->getCatalogues($this->config);
121			foreach ($catalogues as $catalogue) {
122			foreach ($this->remoteStorages as $storage) {
123			if ($storage instanceof TransferableStorage) {
124			$storage->import($catalogue, $importOptions);
125			}
126			}
127			}
128			}
129
130			/**
131			* Get the very latest version we know of a message. First look at the remote storage
132			* fall back on the local ones.
133			*/
134			public function syncAndFetchMessage(string $locale, string $domain, string $key): ?Message
135			{
136			if (null === $message = $this->getFromStorages($this->remoteStorages, $locale, $domain, $key)) {
137			// If message is not in remote storages, try local
138			$message = $this->getFromStorages($this->localStorages, $locale, $domain, $key);
139			}
140
141			if (!$message) {
			0 ignored issues – show introduced 2021-03-26 16:59 UTC by Report Bug Copy Issue Report `$message` is of type `Translation\Common\Model\Message`, thus it always evaluated to `true`. Loading history...
142			return null;
143			}
144
145			$this->updateStorages($this->localStorages, $message);
146
147			return $message;
148			}
149
150			/**
151			* Try to get a translation from all the storages, start looking in the first
152			* local storage and then move on to the remote storages.
153			* {@inheritdoc}
154			*/
155			public function get(string $locale, string $domain, string $key): ?MessageInterface
156			{
157			foreach ([$this->localStorages, $this->remoteStorages] as $storages) {
158			$value = $this->getFromStorages($storages, $locale, $domain, $key);
159			if (null !== $value) {
160			return $value;
161			}
162			}
163
164			return null;
165			}
166
167			/**
168			* @param Storage[] $storages
169			*/
170			private function getFromStorages(array $storages, string $locale, string $domain, string $key): ?Message
171			{
172			foreach ($storages as $storage) {
173			$value = $storage->get($locale, $domain, $key);
174			if (null !== $value) {
175			return $value;
			0 ignored issues – show Bug Best Practice introduced 2021-03-26 16:59 UTC by Report Bug Copy Issue Report The expression `return $value` returns the type `Translation\Common\Model\MessageInterface` which includes types incompatible with the type-hinted return `Translation\Common\Model\Message\|null`. Loading history...
176			}
177			}
178
179			return null;
180			}
181
182			/**
183			* Create all configured storages with this message. This will not overwrite
184			* existing message.
185			*
186			* {@inheritdoc}
187			*/
188			public function create(MessageInterface $message): void
189			{
190			// Validate if message actually has data
191			if (empty((array) $message)) {
192			return;
193			}
194
195			foreach ([$this->localStorages, $this->remoteStorages] as $storages) {
196			/** @var Storage $storage */
197			foreach ($storages as $storage) {
198			$storage->create($message);
199			}
200			}
201			}
202
203			/**
204			* Update all configured storages with this message. If messages does not exist
205			* it will be created.
206			*
207			* {@inheritdoc}
208			*/
209			public function update(MessageInterface $message): void
210			{
211			foreach ([$this->localStorages, $this->remoteStorages] as $storages) {
212			$this->updateStorages($storages, $message);
213			}
214			}
215
216			/**
217			* @param Storage[] $storages
218			*/
219			private function updateStorages(array $storages, MessageInterface $message): void
220			{
221			// Validate if message actually has data
222			if (empty((array) $message)) {
223			return;
224			}
225
226			foreach ($storages as $storage) {
227			$storage->update($message);
228			}
229			}
230
231			/**
232			* Delete the message form all storages.
233			*
234			* {@inheritdoc}
235			*/
236			public function delete(string $locale, string $domain, string $key): void
237			{
238			foreach ([$this->localStorages, $this->remoteStorages] as $storages) {
239			/** @var Storage $storage */
240			foreach ($storages as $storage) {
241			$storage->delete($locale, $domain, $key);
242			}
243			}
244			}
245
246			public function addLocalStorage(Storage $localStorage): self
247			{
248			$this->localStorages[] = $localStorage;
249
250			return $this;
251			}
252
253			public function addRemoteStorage(Storage $remoteStorage): self
254			{
255			$this->remoteStorages[] = $remoteStorage;
256
257			return $this;
258			}
259			}
260

php-translation / symfony-bundle

StorageService::__construct() A last analyzed 2021-03-26 16:59 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

StorageService::__construct() A
last analyzed 2021-03-26 16:59 UTC