MappingException::identifierRequired() - Code Metrics - Inspection of "Merge pull request #1352" - doctrine/mongodb-odm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 61f8e0...b1cbaf )

by Maciej

created 2016-02-20 11:13 UTC

MappingException::identifierRequired() A

↳ Parent: MappingException

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Metric	Value
dl	0
loc	5
ccs	0
cts	3
cp	0
rs	9.4285
cc	1
eloc	3
nc	1
nop	1
crap	2

<?php
/*
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the MIT license. For more information, see
 * <http://www.doctrine-project.org>.
 */

namespace Doctrine\ODM\MongoDB\Mapping;

use Doctrine\Common\Persistence\Mapping\MappingException as BaseMappingException;

/**
 * Class for all exceptions related to the Doctrine MongoDB ODM
 *
 * @since       1.0
 */
class MappingException extends BaseMappingException
{
    /**
     * @param string $name
     * @return MappingException
     */
    public static function typeExists($name)
    {
        return new self('Type ' . $name . ' already exists.');
    }

    /**
     * @param string $name
     * @return MappingException
     */
    public static function typeNotFound($name)
    {
        return new self('Type to be overwritten ' . $name . ' does not exist.');
    }

    /**
     * @param string $className
     * @param string $fieldName
     * @return MappingException
     */
    public static function mappingNotFound($className, $fieldName)
    {
        return new self("No mapping found for field '$fieldName' in class '$className'.");
    }

    /**
     * @param string $className
     * @param string $fieldName
     * @return MappingException
     */
    public static function mappingNotFoundInClassNorDescendants($className, $fieldName)
    {
        return new self("No mapping found for field '$fieldName' in class '$className' nor its descendants.");
    }

    /**
     * @param $fieldName
     * @param $className
     * @param $className2
     * @return MappingException
     */
    public static function referenceFieldConflict($fieldName, $className, $className2)
    {
        return new self("Reference mapping for field '$fieldName' in class '$className' conflicts with one mapped in class '$className2'.");
    }

    /**
     * @param string $document
     * @param string $fieldName
     * @return MappingException
     */
    public static function duplicateFieldMapping($document, $fieldName)
    {
        return new self('Property "' . $fieldName . '" in "' . $document . '" was already declared, but it must be declared only once');
    }

    /**
     * @param string $document
     * @param string $fieldName
     * @return MappingException
     */
    public static function discriminatorFieldConflict($document, $fieldName)
    {
        return new self('Discriminator field "' . $fieldName . '" in "' . $document . '" conflicts with a mapped field\'s "name" attribute.');
    }

    /**
     * Throws an exception that indicates that a class used in a discriminator map does not exist.
     * An example would be an outdated (maybe renamed) classname.
     *
     * @param string $className The class that could not be found
     * @param string $owningClass The class that declares the discriminator map.
     * @return MappingException
     */
    public static function invalidClassInDiscriminatorMap($className, $owningClass)
    {
        return new self(
            "Document class '$className' used in the discriminator map of class '$owningClass' " .
            "does not exist."
        );
    }

    /**
     * Throws an exception that indicates a discriminator value does not exist in a map
     *
     * @param string $value The discriminator value that could not be found
     * @param string $owningClass The class that declares the discriminator map
     * @return MappingException
     */
    public static function invalidDiscriminatorValue($value, $owningClass)
    {
        return new self("Discriminator value '$value' used in the declaration of class '$owningClass' does not exist.");
    }

    /**
     * @param string $className
     * @return MappingException
     */
    public static function missingFieldName($className)
    {
        return new self("The Document class '$className' field mapping misses the 'fieldName' attribute.");
    }

    /**
     * @param string $className
     * @return MappingException
     */
    public static function classIsNotAValidDocument($className)
    {
        return new self('Class ' . $className . ' is not a valid document or mapped super class.');
    }

    /**
     * Exception for reflection exceptions - adds the document name,
     * because there might be long classnames that will be shortened
     * within the stacktrace
     *
     * @param string $document The document's name
     * @param \ReflectionException $previousException
     * @return \Doctrine\ODM\MongoDB\Mapping\MappingException
     */
    public static function reflectionFailure($document, \ReflectionException $previousException)
    {
        return new self('An error occurred in ' . $document, 0, $previousException);
    }

    /**
     * @param string $documentName
     * @return MappingException
     */
    public static function identifierRequired($documentName)
    {
        return new self("No identifier/primary key specified for Document '$documentName'."
            . " Every Document must have an identifier/primary key.");
    }

    /**
     * @param string $className
     * @param string $fieldName
     * @return MappingException
     */
    public static function missingIdentifierField($className, $fieldName)
    {
        return new self("The identifier $fieldName is missing for a query of " . $className);
    }

    /**
     * @param string $className
     * @return MappingException
     */
    public static function missingIdGeneratorClass($className)
    {
        return new self("The class-option for the custom ID generator is missing in class $className.");
    }

    /**
     * @param string $className
     * @return MappingException
     */
    public static function classIsNotAValidGenerator($className)
    {
        return new self("The class $className if not a valid ID generator of type AbstractIdGenerator.");
    }

    /**
     * @param string $className
     * @param string $optionName
     * @return MappingException
     */
    public static function missingGeneratorSetter($className, $optionName)
    {
        return new self("The class $className is missing a setter for the option $optionName.");
    }

    /**
     * @param string $className
     * @param string $fieldName
     * @return MappingException
     */
    public static function cascadeOnEmbeddedNotAllowed($className, $fieldName)
    {
        return new self("Cascade on $className::$fieldName is not allowed.");
    }

    /**
     * @param string $className
     * @param string $fieldName
     * @return MappingException
     */
    public static function simpleReferenceRequiresTargetDocument($className, $fieldName)
    {
        return new self("Target document must be specified for simple reference: $className::$fieldName");
    }

    /**
     * @param string $targetDocument
     * @return MappingException
     */
    public static function simpleReferenceMustNotTargetDiscriminatedDocument($targetDocument)
    {
        return new self("Simple reference must not target document using Single Collection Inheritance, $targetDocument targeted.");
    }

    /**
     * @param string $strategy
     * @param string $className
     * @param string $fieldName
     * @return MappingException
     */
    public static function atomicCollectionStrategyNotAllowed($strategy, $className, $fieldName)
    {
        return new self("$strategy collection strategy can be used only in top level document, used in $className::$fieldName");
    }

    /**
     * @param string $className
     * @param string $fieldName
     * @return MappingException
     */
    public static function owningAndInverseReferencesRequireTargetDocument($className, $fieldName)
    {
        return new self("Target document must be specified for owning/inverse sides of reference: $className::$fieldName");
    }

    /**
     * @param string $className
     * @param string $fieldName
     * @return MappingException
     */
    public static function mustNotChangeIdentifierFieldsType($className, $fieldName)
    {
        return new self("$className::$fieldName was declared an identifier and must stay this way.");
    }

    /**
     * @param string $className
     * @param string $fieldName
     * @param string $strategy
     * @return MappingException
     */
    public static function referenceManySortMustNotBeUsedWithNonSetCollectionStrategy($className, $fieldName, $strategy)
    {
        return new self("ReferenceMany's sort can not be used with addToSet and pushAll strategies, $strategy used in $className::$fieldName");
    }

    /**
     * @param string $className
     * @param string $fieldName
     * @param string $type
     * @param string $strategy
     * @return MappingException
     */
    public static function invalidStorageStrategy($className, $fieldName, $type, $strategy)
    {
        return new self("Invalid strategy $strategy used in $className::$fieldName with type $type");
    }
}


1		<?php
2		/*
3		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
4		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
5		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
6		* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
7		* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
8		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
9		* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
10		* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
11		* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
12		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
13		* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
14		*
15		* This software consists of voluntary contributions made by many individuals
16		* and is licensed under the MIT license. For more information, see
17		* <http://www.doctrine-project.org>.
18		*/
19
20		namespace Doctrine\ODM\MongoDB\Mapping;
21
22		use Doctrine\Common\Persistence\Mapping\MappingException as BaseMappingException;
23
24		/**
25		* Class for all exceptions related to the Doctrine MongoDB ODM
26		*
27		* @since 1.0
28		*/
29		class MappingException extends BaseMappingException
30		{
31		/**
32		* @param string $name
33		* @return MappingException
34		*/
35		public static function typeExists($name)
36		{
37		return new self('Type ' . $name . ' already exists.');
38		}
39
40		/**
41		* @param string $name
42		* @return MappingException
43		*/
44		public static function typeNotFound($name)
45		{
46		return new self('Type to be overwritten ' . $name . ' does not exist.');
47		}
48
49		/**
50		* @param string $className
51		* @param string $fieldName
52		* @return MappingException
53		*/
54	6	public static function mappingNotFound($className, $fieldName)
55		{
56	6	return new self("No mapping found for field '$fieldName' in class '$className'.");
57		}
58
59		/**
60		* @param string $className
61		* @param string $fieldName
62		* @return MappingException
63		*/
64	2	public static function mappingNotFoundInClassNorDescendants($className, $fieldName)
65		{
66	2	return new self("No mapping found for field '$fieldName' in class '$className' nor its descendants.");
67		}
68
69		/**
70		* @param $fieldName
71		* @param $className
72		* @param $className2
73		* @return MappingException
74		*/
75	2	public static function referenceFieldConflict($fieldName, $className, $className2)
76		{
77	2	return new self("Reference mapping for field '$fieldName' in class '$className' conflicts with one mapped in class '$className2'.");
78		}
79
80		/**
81		* @param string $document
82		* @param string $fieldName
83		* @return MappingException
84		*/
85		public static function duplicateFieldMapping($document, $fieldName)
86		{
87		return new self('Property "' . $fieldName . '" in "' . $document . '" was already declared, but it must be declared only once');
88		}
89
90		/**
91		* @param string $document
92		* @param string $fieldName
93		* @return MappingException
94		*/
95	2	public static function discriminatorFieldConflict($document, $fieldName)
96		{
97	2	return new self('Discriminator field "' . $fieldName . '" in "' . $document . '" conflicts with a mapped field\'s "name" attribute.');
98		}
99
100		/**
101		* Throws an exception that indicates that a class used in a discriminator map does not exist.
102		* An example would be an outdated (maybe renamed) classname.
103		*
104		* @param string $className The class that could not be found
105		* @param string $owningClass The class that declares the discriminator map.
106		* @return MappingException
107		*/
108		public static function invalidClassInDiscriminatorMap($className, $owningClass)
109		{
110		return new self(
111		"Document class '$className' used in the discriminator map of class '$owningClass' " .
112		"does not exist."
113		);
114		}
115
116		/**
117		* Throws an exception that indicates a discriminator value does not exist in a map
118		*
119		* @param string $value The discriminator value that could not be found
120		* @param string $owningClass The class that declares the discriminator map
121		* @return MappingException
122		*/
123		public static function invalidDiscriminatorValue($value, $owningClass)
124		{
125		return new self("Discriminator value '$value' used in the declaration of class '$owningClass' does not exist.");
126		}
127
128		/**
129		* @param string $className
130		* @return MappingException
131		*/
132		public static function missingFieldName($className)
133		{
134		return new self("The Document class '$className' field mapping misses the 'fieldName' attribute.");
135		}
136
137		/**
138		* @param string $className
139		* @return MappingException
140		*/
141	2	public static function classIsNotAValidDocument($className)
142		{
143	2	return new self('Class ' . $className . ' is not a valid document or mapped super class.');
144		}
145
146		/**
147		* Exception for reflection exceptions - adds the document name,
148		* because there might be long classnames that will be shortened
149		* within the stacktrace
150		*
151		* @param string $document The document's name
152		* @param \ReflectionException $previousException
153		* @return \Doctrine\ODM\MongoDB\Mapping\MappingException
154		*/
155		public static function reflectionFailure($document, \ReflectionException $previousException)
156		{
157		return new self('An error occurred in ' . $document, 0, $previousException);
158		}
159
160		/**
161		* @param string $documentName
162		* @return MappingException
163		*/
164		public static function identifierRequired($documentName)
165		{
166		return new self("No identifier/primary key specified for Document '$documentName'."
167		. " Every Document must have an identifier/primary key.");
168		}
169
170		/**
171		* @param string $className
172		* @param string $fieldName
173		* @return MappingException
174		*/
175		public static function missingIdentifierField($className, $fieldName)
176		{
177		return new self("The identifier $fieldName is missing for a query of " . $className);
178		}
179
180		/**
181		* @param string $className
182		* @return MappingException
183		*/
184		public static function missingIdGeneratorClass($className)
185		{
186		return new self("The class-option for the custom ID generator is missing in class $className.");
187		}
188
189		/**
190		* @param string $className
191		* @return MappingException
192		*/
193		public static function classIsNotAValidGenerator($className)
194		{
195		return new self("The class $className if not a valid ID generator of type AbstractIdGenerator.");
196		}
197
198		/**
199		* @param string $className
200		* @param string $optionName
201		* @return MappingException
202		*/
203		public static function missingGeneratorSetter($className, $optionName)
204		{
205		return new self("The class $className is missing a setter for the option $optionName.");
206		}
207
208		/**
209		* @param string $className
210		* @param string $fieldName
211		* @return MappingException
212		*/
213	1	public static function cascadeOnEmbeddedNotAllowed($className, $fieldName)
214		{
215	1	return new self("Cascade on $className::$fieldName is not allowed.");
216		}
217
218		/**
219		* @param string $className
220		* @param string $fieldName
221		* @return MappingException
222		*/
223	1	public static function simpleReferenceRequiresTargetDocument($className, $fieldName)
224		{
225	1	return new self("Target document must be specified for simple reference: $className::$fieldName");
226		}
227
228		/**
229		* @param string $targetDocument
230		* @return MappingException
231		*/
232	1	public static function simpleReferenceMustNotTargetDiscriminatedDocument($targetDocument)
233		{
234	1	return new self("Simple reference must not target document using Single Collection Inheritance, $targetDocument targeted.");
235		}
236
237		/**
238		* @param string $strategy
239		* @param string $className
240		* @param string $fieldName
241		* @return MappingException
242		*/
243	1	public static function atomicCollectionStrategyNotAllowed($strategy, $className, $fieldName)
244		{
245	1	return new self("$strategy collection strategy can be used only in top level document, used in $className::$fieldName");
246		}
247
248		/**
249		* @param string $className
250		* @param string $fieldName
251		* @return MappingException
252		*/
253	4	public static function owningAndInverseReferencesRequireTargetDocument($className, $fieldName)
254		{
255	4	return new self("Target document must be specified for owning/inverse sides of reference: $className::$fieldName");
256		}
257
258		/**
259		* @param string $className
260		* @param string $fieldName
261		* @return MappingException
262		*/
263	1	public static function mustNotChangeIdentifierFieldsType($className, $fieldName)
264		{
265	1	return new self("$className::$fieldName was declared an identifier and must stay this way.");
266		}
267
268		/**
269		* @param string $className
270		* @param string $fieldName
271		* @param string $strategy
272		* @return MappingException
273		*/
274	1	public static function referenceManySortMustNotBeUsedWithNonSetCollectionStrategy($className, $fieldName, $strategy)
275		{
276	1	return new self("ReferenceMany's sort can not be used with addToSet and pushAll strategies, $strategy used in $className::$fieldName");
277		}
278
279		/**
280		* @param string $className
281		* @param string $fieldName
282		* @param string $type
283		* @param string $strategy
284		* @return MappingException
285		*/
286		public static function invalidStorageStrategy($className, $fieldName, $type, $strategy)
287		{
288		return new self("Invalid strategy $strategy used in $className::$fieldName with type $type");
289		}
290		}
291

doctrine / mongodb-odm

Push — master ( 61f8e0...b1cbaf )

MappingException::identifierRequired() A

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like