Localization_Scanner_StringsCollection::countWarnings() - Code Metrics - Mistralys/application-localization - Measure and Improve Code Quality continuously with Scrutinizer

countWarnings() A
last analyzed 2024-10-22 14:10 UTC

↳ Parent: Localization_Scanner_StringsCollection

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	1
c	0
b	0
f	0
nc	1
nop	0
dl	0
loc	3
rs	10

<?php

namespace AppLocalize;

use AppLocalize\Parser\Text;

class Localization_Scanner_StringsCollection
{
    const ERROR_UNKNOWN_STRING_HASH = 39201;
    
    const SOURCE_FILE = 'file';
    
    const STORAGE_FORMAT_VERSION = 2;
    
   /**
    * @var Localization_Scanner
    */
    protected $scanner;
    
   /**
    * @var Localization_Scanner_StringHash[]
    */
    protected $hashes = array();
    
   /**
    * @var array
    */
    protected $warnings = array();
    
    public function __construct(Localization_Scanner $scanner)
    {
        $this->scanner = $scanner;
    }
    
    public function addFromFile(string $sourceID, string $relativePath, string $languageType, Text $text) : void
    {
        $string = $this->createString($sourceID, self::SOURCE_FILE, $text);
        
        $string->setProperty('languageType', $languageType);
        $string->setProperty('relativePath', $relativePath);
        
        $this->add($string);
    }
    
    public function addWarning(Localization_Parser_Warning $warning) : void
    {
        $this->warnings[] = $warning->toArray();
    }
    
    protected function createString(string $sourceID, string $sourceType, Text $text) : Localization_Scanner_StringInfo
    {
        return new Localization_Scanner_StringInfo($this, $sourceID, $sourceType, $text);
    }
    
   /**
    * Adds a single translatable string.
    * 
    * @param Localization_Scanner_StringInfo $string
    * @return Localization_Scanner_StringsCollection
    */
    protected function add(Localization_Scanner_StringInfo $string) : Localization_Scanner_StringsCollection
    {
        $hash = $string->getHash();
        
        if(!isset($this->hashes[$hash])) {
            $this->hashes[$hash] = new Localization_Scanner_StringHash($this, $hash);
        }
        
        $this->hashes[$hash]->addString($string);
        return $this;
    }
    
   /**
    * Retrieves all available translatable strings,
    * grouped by their hash to identify unique strings.
    * 
    * @return Localization_Scanner_StringHash[]
    */
    public function getHashes() : array
    {
        return array_values($this->hashes);
    }
    
    public function hashExists(string $hash) : bool
    {
        return isset($this->hashes[$hash]);
    }

    /**
     * @param string $hash
     * @return Localization_Scanner_StringHash
     * @throws Localization_Exception
     */
    public function getHash(string $hash) : Localization_Scanner_StringHash
    {
        if(isset($this->hashes[$hash])) {
            return $this->hashes[$hash];
        }
        
        throw new Localization_Exception(
            'Unknown string hash',
            sprintf('Could not find string by hash [%s].', $hash),
            self::ERROR_UNKNOWN_STRING_HASH
        );
    }

    /**
     * @return array<string,mixed>
     */
    public function toArray() : array
    {
        $data = array(
            'formatVersion' => self::STORAGE_FORMAT_VERSION,
            'hashes' => array(),
            'warnings' => array()
        );
        
        foreach($this->hashes as $hash)
        {
            $data['hashes'] = array_merge($data['hashes'], $hash->toArray());
        }
        
        $data['warnings'] = $this->warnings;
        
        return $data;
    }

    /**
     * @param array<int|string,mixed> $array
     * @return bool
     */
    public function fromArray(array $array) : bool
    {
        if(!isset($array['formatVersion']) || $array['formatVersion'] != self::STORAGE_FORMAT_VERSION) {
            return false;
        }
        
        foreach($array['hashes'] as $entry) 
        {
            $string = Localization_Scanner_StringInfo::fromArray($this, $entry);
            $this->add($string);
        }
        
        $this->warnings = $array['warnings'];
        
        return true;
    }
    
   /**
    * Whether the parser reported warnings during the
    * search for translatable texts.
    * 
    * @return bool
    */
    public function hasWarnings() : bool
    {
        return !empty($this->warnings);
    }
    
   /**
    * Retrieves the amount of warnings.
    * @return int
    */
    public function countWarnings() : int
    {
        return count($this->warnings);
    }
    
   /**
    * Retrieves all warning messages that were added
    * during the search for translatable texts, if any.
    * 
    * @return Localization_Scanner_StringsCollection_Warning[]
    */
    public function getWarnings() : array
    {
        $result = array();
        
        foreach($this->warnings as $def) {
            $result[] = new Localization_Scanner_StringsCollection_Warning($def);
        }
        
        return $result;
    }
    
    public function countHashes() : int
    {
        return count($this->hashes);
    }
    
    public function countFiles() : int
    {
        $amount = 0;
        foreach($this->hashes as $hash) {
            $amount = $amount + $hash->countFiles();
        }
        
        return $amount;
    }
    
   /**
    * Retrieves all string hashed for the specified source.
    * 
    * @param string $id
    * @return Localization_Scanner_StringHash[]
    */
    public function getHashesBySourceID(string $id) : array
    {
        $hashes = array();
        
        foreach($this->hashes as $hash) {
            if($hash->hasSourceID($id)) {
                $hashes[] = $hash;
            }
        }
        
        return $hashes;
    }
    
   /**
    * Retrieves all hashes for the specified language ID.
    * 
    * @param string $languageID The language ID, e.g. "PHP"
    * @return Localization_Scanner_StringHash[]
    */
    public function getHashesByLanguageID(string $languageID) : array
    {
        $hashes = array();
        
        foreach($this->hashes as $hash) {
            if($hash->hasLanguageType($languageID)) {
                $hashes[] = $hash;
            }
        }
        
        return $hashes;
    }
}

1			<?php
2
3			namespace AppLocalize;
4
5			use AppLocalize\Parser\Text;
6
7			class Localization_Scanner_StringsCollection
8			{
9			const ERROR_UNKNOWN_STRING_HASH = 39201;
10
11			const SOURCE_FILE = 'file';
12
13			const STORAGE_FORMAT_VERSION = 2;
14
15			/**
16			* @var Localization_Scanner
17			*/
18			protected $scanner;
19
20			/**
21			* @var Localization_Scanner_StringHash[]
22			*/
23			protected $hashes = array();
24
25			/**
26			* @var array
27			*/
28			protected $warnings = array();
29
30			public function __construct(Localization_Scanner $scanner)
31			{
32			$this->scanner = $scanner;
33			}
34
35			public function addFromFile(string $sourceID, string $relativePath, string $languageType, Text $text) : void
36			{
37			$string = $this->createString($sourceID, self::SOURCE_FILE, $text);
38
39			$string->setProperty('languageType', $languageType);
40			$string->setProperty('relativePath', $relativePath);
41
42			$this->add($string);
43			}
44
45			public function addWarning(Localization_Parser_Warning $warning) : void
46			{
47			$this->warnings[] = $warning->toArray();
48			}
49
50			protected function createString(string $sourceID, string $sourceType, Text $text) : Localization_Scanner_StringInfo
51			{
52			return new Localization_Scanner_StringInfo($this, $sourceID, $sourceType, $text);
53			}
54
55			/**
56			* Adds a single translatable string.
57			*
58			* @param Localization_Scanner_StringInfo $string
59			* @return Localization_Scanner_StringsCollection
60			*/
61			protected function add(Localization_Scanner_StringInfo $string) : Localization_Scanner_StringsCollection
62			{
63			$hash = $string->getHash();
64
65			if(!isset($this->hashes[$hash])) {
66			$this->hashes[$hash] = new Localization_Scanner_StringHash($this, $hash);
67			}
68
69			$this->hashes[$hash]->addString($string);
70			return $this;
71			}
72
73			/**
74			* Retrieves all available translatable strings,
75			* grouped by their hash to identify unique strings.
76			*
77			* @return Localization_Scanner_StringHash[]
78			*/
79			public function getHashes() : array
80			{
81			return array_values($this->hashes);
82			}
83
84			public function hashExists(string $hash) : bool
85			{
86			return isset($this->hashes[$hash]);
87			}
88
89			/**
90			* @param string $hash
91			* @return Localization_Scanner_StringHash
92			* @throws Localization_Exception
93			*/
94			public function getHash(string $hash) : Localization_Scanner_StringHash
95			{
96			if(isset($this->hashes[$hash])) {
97			return $this->hashes[$hash];
98			}
99
100			throw new Localization_Exception(
101			'Unknown string hash',
102			sprintf('Could not find string by hash [%s].', $hash),
103			self::ERROR_UNKNOWN_STRING_HASH
104			);
105			}
106
107			/**
108			* @return array<string,mixed>
109			*/
110			public function toArray() : array
111			{
112			$data = array(
113			'formatVersion' => self::STORAGE_FORMAT_VERSION,
114			'hashes' => array(),
115			'warnings' => array()
116			);
117
118			foreach($this->hashes as $hash)
119			{
120			$data['hashes'] = array_merge($data['hashes'], $hash->toArray());
121			}
122
123			$data['warnings'] = $this->warnings;
124
125			return $data;
126			}
127
128			/**
129			* @param array<int\|string,mixed> $array
130			* @return bool
131			*/
132			public function fromArray(array $array) : bool
133			{
134			if(!isset($array['formatVersion']) \|\| $array['formatVersion'] != self::STORAGE_FORMAT_VERSION) {
135			return false;
136			}
137
138			foreach($array['hashes'] as $entry)
139			{
140			$string = Localization_Scanner_StringInfo::fromArray($this, $entry);
141			$this->add($string);
142			}
143
144			$this->warnings = $array['warnings'];
145
146			return true;
147			}
148
149			/**
150			* Whether the parser reported warnings during the
151			* search for translatable texts.
152			*
153			* @return bool
154			*/
155			public function hasWarnings() : bool
156			{
157			return !empty($this->warnings);
158			}
159
160			/**
161			* Retrieves the amount of warnings.
162			* @return int
163			*/
164			public function countWarnings() : int
165			{
166			return count($this->warnings);
167			}
168
169			/**
170			* Retrieves all warning messages that were added
171			* during the search for translatable texts, if any.
172			*
173			* @return Localization_Scanner_StringsCollection_Warning[]
174			*/
175			public function getWarnings() : array
176			{
177			$result = array();
178
179			foreach($this->warnings as $def) {
180			$result[] = new Localization_Scanner_StringsCollection_Warning($def);
181			}
182
183			return $result;
184			}
185
186			public function countHashes() : int
187			{
188			return count($this->hashes);
189			}
190
191			public function countFiles() : int
192			{
193			$amount = 0;
194			foreach($this->hashes as $hash) {
195			$amount = $amount + $hash->countFiles();
196			}
197
198			return $amount;
199			}
200
201			/**
202			* Retrieves all string hashed for the specified source.
203			*
204			* @param string $id
205			* @return Localization_Scanner_StringHash[]
206			*/
207			public function getHashesBySourceID(string $id) : array
208			{
209			$hashes = array();
210
211			foreach($this->hashes as $hash) {
212			if($hash->hasSourceID($id)) {
213			$hashes[] = $hash;
214			}
215			}
216
217			return $hashes;
218			}
219
220			/**
221			* Retrieves all hashes for the specified language ID.
222			*
223			* @param string $languageID The language ID, e.g. "PHP"
224			* @return Localization_Scanner_StringHash[]
225			*/
226			public function getHashesByLanguageID(string $languageID) : array
227			{
228			$hashes = array();
229
230			foreach($this->hashes as $hash) {
231			if($hash->hasLanguageType($languageID)) {
232			$hashes[] = $hash;
233			}
234			}
235
236			return $hashes;
237			}
238			}

Mistralys / application-localization

countWarnings() A last analyzed 2024-10-22 14:10 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

countWarnings() A
last analyzed 2024-10-22 14:10 UTC