AbstractModel::getExtendsClassName() - Code Metrics - Inspection of "issue #92 - improve lisibility" - WsdlToPhp/PackageGenerator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — feature/issue-92 ( 67f652...bf7282 )

by Mikaël

created 2017-05-16 19:17 UTC

AbstractModel::getExtendsClassName() A

↳ Parent: AbstractModel

Complexity

Conditions	4
Paths	4

Size

Total Lines	11
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	11
rs	9.2
c	0
b	0
f	0
cc	4
eloc	7
nc	4
nop	0

<?php

namespace WsdlToPhp\PackageGenerator\Model;

use WsdlToPhp\PackageGenerator\ConfigurationReader\GeneratorOptions;
use WsdlToPhp\PackageGenerator\ConfigurationReader\PhpReservedKeyword;
use WsdlToPhp\PackageGenerator\ConfigurationReader\AbstractReservedWord;
use WsdlToPhp\PackageGenerator\Generator\Generator;
use WsdlToPhp\PackageGenerator\Generator\Utils as GeneratorUtils;
use WsdlToPhp\PackageGenerator\Generator\AbstractGeneratorAware;

/**
 * Class AbstractModel defines the basic properties and methods to operations and structs extracted from the WSDL
 */
abstract class AbstractModel extends AbstractGeneratorAware
{
    /**
     * Constant used to define the key to store documentation value in meta
     * @var string
     */
    const META_DOCUMENTATION = 'documentation';
    /**
     * Original name od the element
     * @var string
     */
    private $name = '';
    /**
     * Values associated to the operation
     * @var string[]
     */
    private $meta = array();
    /**
     * Define the inheritance of a struct by the name of the parent struct or type
     * @var string
     */
    private $inheritance = '';
    /**
     * Store the object which owns the current model
     * @var AbstractModel
     */
    private $owner = null;
    /**
     * Indicates that the current elemen is an abstract element.
     * It allows to generated an abstract class.
     * This will happen for element/complexType that are defined with abstract="true"
     * @var bool
     */
    private $isAbstract = false;
    /**
     * Replaced keywords time in order to generate unique new keyword
     * @var array
     */
    private static $replacedPhpReservedKeywords = array();
    /**
     * Replaced methods time in order to generate unique new method
     * @var array
     */
    private $replacedReservedMethods = array();
    /**
     * Unique name generated in order to ensure unique naming (for struct constructor and setters/getters even for different case attribute name whith same value)
     * @var array
     */
    private static $uniqueNames = array();
    /**
     * Main constructor
     * @uses AbstractModel::setName()
     * @param Generator $generator
     * @param string $name the original name
     */
    public function __construct(Generator $generator, $name)
    {
        parent::__construct($generator);
        $this->setName($name);
    }
    /**
     * @uses AbstractModel::getInheritedModel()
     * @uses AbstractModel::getPackagedName()
     * @uses AbstractModel::getExtends()
     * @uses Struct::isStruct()
     * @return string
     */
    public function getExtendsClassName()
    {
        $extends = '';
        if (($model = $this->getInheritedModel()) instanceof Struct && $model->isStruct()) {
            $extends = $model->getPackagedName($model->isRestriction());
        }
        if (empty($extends)) {
            $extends = $this->getExtends(true);
        }
        return $extends;
    }
    /**
     * Returns the name of the class the current class inherits from
     * @return string
     */
    public function getInheritance()
    {
        return $this->inheritance;
    }
    /**
     * Sets the name of the class the current class inherits from
     * @param string $inheritance
     * @return AbstractModel
     */
    public function setInheritance($inheritance = '')
    {
        $this->inheritance = $inheritance;
        return $this;
    }
    /**
     * @uses AbstractGeneratorAware::getGenerator()
     * @uses Generator::getStruct()
     * @uses AbstractModel::getInheritance()
     * @return Struct
     */
    public function getInheritedModel()
    {
        return $this->getGenerator()->getStruct($this->getInheritance());
    }
    /**
     * Returns the meta
     * @return string[]
     */
    public function getMeta()
    {
        return $this->meta;
    }
    /**
     * Sets the meta
     * @param string[] $meta
     * @return AbstractModel
     */
    public function setMeta(array $meta = array())
    {
        $this->meta = $meta;
        return $this;
    }
    /**
     * Add meta information to the operation
     * @uses AbstractModel::getMeta()
     * @throws \InvalidArgumentException
     * @param string $metaName
     * @param mixed $metaValue
     * @return AbstractModel
     */
    public function addMeta($metaName, $metaValue)
    {
        if (!is_scalar($metaName) || (!is_scalar($metaValue) && !is_array($metaValue))) {
            throw new \InvalidArgumentException(sprintf('Invalid meta name "%s" or value "%s". Please provide scalar meta name and scalar or array meta value.', gettype($metaName), gettype($metaValue)), __LINE__);
        }
        $metaValue = is_scalar($metaValue) ? trim($metaValue) : $metaValue;
        if ((is_scalar($metaValue) && $metaValue !== '') || is_array($metaValue)) {
            if (!array_key_exists($metaName, $this->meta)) {
                $this->meta[$metaName] = $metaValue;
            } elseif (is_array($this->meta[$metaName]) && is_array($metaValue)) {
                $this->meta[$metaName] = array_merge($this->meta[$metaName], $metaValue);
            } elseif (is_array($this->meta[$metaName])) {
                array_push($this->meta[$metaName], $metaValue);
            } else {
                $this->meta[$metaName] = $metaValue;
            }
            ksort($this->meta);
        }
        return $this;
    }
    /**
     * Sets the documentation meta value.
     * Documentation is set as an array so if multiple documentation nodes are set for an unique element, it will gather them.
     * @uses AbstractModel::META_DOCUMENTATION
     * @uses AbstractModel::addMeta()
     * @param string $documentation the documentation from the WSDL
     * @return AbstractModel
     */
    public function setDocumentation($documentation)
    {
        return $this->addMeta(self::META_DOCUMENTATION, is_array($documentation) ? $documentation : array(
            $documentation,
        ));
    }
    /**
     * Returns a meta value according to its name
     * @uses AbstractModel::getMeta()
     * @param string $metaName the meta information name
     * @param mixed $fallback the fallback value if unset
     * @return mixed the meta information value
     */
    public function getMetaValue($metaName, $fallback = null)
    {
        $meta = $this->getMeta();
        return array_key_exists($metaName, $meta) ? $meta[$metaName] : $fallback;
    }
    /**
     * Returns the value of the first meta value assigned to the name
     * @param string[] $names the meta names to check
     * @param mixed $fallback the fallback value if anyone is set
     * @return mixed the meta information value
     */
    public function getMetaValueFirstSet(array $names, $fallback = null)
    {
        $meta = $this->getMeta();
        foreach ($names as $name) {
            if (array_key_exists($name, $meta)) {
                return $meta[$name];
            }
        }
        return $fallback;
    }
    /**
     * Returns the original name extracted from the WSDL
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }
    /**
     * Sets the original name extracted from the WSDL
     * @param string $name
     * @return AbstractModel
     */
    public function setName($name)
    {
        $this->name = $name;
        return $this;
    }
    /**
     * Returns a valid clean name for PHP
     * @uses AbstractModel::getName()
     * @uses AbstractModel::cleanString()
     * @param bool $keepMultipleUnderscores optional, allows to keep the multiple consecutive underscores
     * @return string
     */
    public function getCleanName($keepMultipleUnderscores = true)
    {
        return self::cleanString($this->getName(), $keepMultipleUnderscores);
    }
    /**
     * Returns the owner model object
     * @return AbstractModel
     */
    public function getOwner()
    {
        return $this->owner;
    }
    /**
     * Sets the owner model object
     * @param AbstractModel $owner object the owner of the current model
     * @return AbstractModel
     */
    public function setOwner(AbstractModel $owner)
    {
        $this->owner = $owner;
        return $this;
    }
    /**
     * @return bool
     */
    public function isAbstract()
    {
        return $this->isAbstract;
    }
    /**
     * @param bool $isAbstract
     * @return AbstractModel
     */
    public function setAbstract($isAbstract)
    {
        $this->isAbstract = $isAbstract;
        return $this;
    }
    /**
     * Returns true if the original name is safe to use as a PHP property, variable name or class name
     * @uses AbstractModel::getName()
     * @uses AbstractModel::getCleanName()
     * @return bool
     */
    public function nameIsClean()
    {
        return ($this->getName() !== '' && $this->getName() === $this->getCleanName());
    }
    /**
     * Returns the packaged name
     * @uses AbstractModel::getNamespace()
     * @uses AbstractModel::getCleanName()
     * @uses AbstractModel::getContextualPart()
     * @uses AbstractModel::uniqueName()
     * @uses AbstractModel::replacePhpReservedKeyword()
     * @uses AbstractGeneratorAware::getGenerator()
     * @uses Generator::getOptionPrefix()
     * @uses Generator::getOptionSuffix()
     * @uses AbstractModel::uniqueName() to ensure unique naming of struct case sensitively
     * @return string
     */
    public function getPackagedName($namespaced = false)
    {
        $nameParts = array();
        if ($namespaced && $this->getNamespace() !== '') {
            $nameParts[] = sprintf('\%s\\', $this->getNamespace());
        }
        $cleanName = $this->getCleanName();
        if ($this->getGenerator()->getOptionPrefix() !== '') {
            $nameParts[] = $this->getGenerator()->getOptionPrefix();
        } else {
            $cleanName = self::replacePhpReservedKeyword($cleanName);
        }
        $nameParts[] = ucfirst(self::uniqueName($cleanName, $this->getContextualPart()));
        if ($this->getGenerator()->getOptionSuffix() !== '') {
            $nameParts[] = $this->getGenerator()->getOptionSuffix();
        }
        return implode('', $nameParts);
    }
    /**
     * Allows to define the contextual part of the class name for the package
     * @return string
     */
    public function getContextualPart()
    {
        return '';
    }
    /**
     * Allows to define from which class the curent model extends
     * @param bool $short
     * @return string|null
     */
    public function getExtends($short = false)
    {
        return '';
    }
    /**
     * @uses AbstractGeneratorAware::getGenerator()
     * @uses Generator::getOptionNamespacePrefix()
     * @uses Generator::getOptionPrefix()
     * @uses Generator::getOptionSuffix()
     * @uses AbstractModel::getSubDirectory()
     * @return string
     */
    public function getNamespace()
    {
        $namespaces = array();
        $namespace = $this->getGenerator()->getOptionNamespacePrefix();
        if (empty($namespace)) {
            if ($this->getGenerator()->getOptionPrefix() !== '') {
                $namespaces[] = $this->getGenerator()->getOptionPrefix();
            } elseif ($this->getGenerator()->getOptionSuffix() !== '') {
                $namespaces[] = $this->getGenerator()->getOptionSuffix();
            }
        } else {
            $namespaces[] = $namespace;
        }
        if ($this->getSubDirectory() !== '') {
            $namespaces[] = $this->getSubDirectory();
        }
        return implode('\\', $namespaces);
    }
    /**
     * Returns directory where to store class and create it if needed
     * @uses AbstractGeneratorAware::getGenerator()
     * @uses AbstractModel::getOptionCategory()
     * @uses AbstractGeneratorAware::getContextualPart()
     * @uses GeneratorOptions::VALUE_CAT
     * @return string
     */
    public function getSubDirectory()
    {
        $subDirectory = '';
        if ($this->getGenerator()->getOptionCategory() === GeneratorOptions::VALUE_CAT) {
            $subDirectory = $this->getContextualPart();
        }
        return $subDirectory;
    }
    /**
     * Returns the sub package name which the model belongs to
     * Must be overridden by sub classes
     * @return array
     */
    public function getDocSubPackages()
    {
        return array();
    }
    /**
     * Clean a string to make it valid as PHP variable
     * @uses GeneratorUtils::cleanString()
     * @param string $string the string to clean
     * @param bool $keepMultipleUnderscores optional, allows to keep the multiple consecutive underscores
     * @return string
     */
    public static function cleanString($string, $keepMultipleUnderscores = true)
    {
        return GeneratorUtils::cleanString($string, $keepMultipleUnderscores);
    }
    /**
     * Returns a usable keyword for a original keyword
     * @uses PhpReservedKeyword::instance()
     * @uses PhpReservedKeyword::is()
     * @param string $keyword the keyword
     * @param string $context the context
     * @return string
     */
    public static function replacePhpReservedKeyword($keyword, $context = null)
    {
        if (PhpReservedKeyword::instance()->is($keyword)) {
            if ($context !== null) {
                $keywordKey = $keyword . '_' . $context;
                if (!array_key_exists($keywordKey, self::$replacedPhpReservedKeywords)) {
                    self::$replacedPhpReservedKeywords[$keywordKey] = 0;
                } else {
                    self::$replacedPhpReservedKeywords[$keywordKey]++;
                }
                return '_' . $keyword . (self::$replacedPhpReservedKeywords[$keywordKey] ? '_' . self::$replacedPhpReservedKeywords[$keywordKey] : '');
            } else {
                return '_' . $keyword;
            }
        } else {
            return $keyword;
        }
    }
    /**
     * @throws \InvalidArgumentException
     * @param $filename
     * @return AbstractReservedWord
     */
    public function getReservedMethodsInstance($filename = null)
    {
        throw new \InvalidArgumentException(sprintf('The method %s should be defined in the class %s', __FUNCTION__, get_called_class(), __LINE__));
    }
    /**
     * Returns a usable method for a original method
     * @uses PhpReservedKeywords::instance()
     * @uses PhpReservedKeywords::is()
     * @param string $methodName the method name
     * @param string $context the context
     * @return string
     */
    public function replaceReservedMethod($methodName, $context = null)
    {
        if ($this->getReservedMethodsInstance()->is($methodName)) {
            if ($context !== null) {
                $methodKey = $methodName . '_' . $context;
                if (!array_key_exists($methodKey, $this->replacedReservedMethods)) {
                    $this->replacedReservedMethods[$methodKey] = 0;
                } else {
                    $this->replacedReservedMethods[$methodKey]++;
                }
                return '_' . $methodName . ($this->replacedReservedMethods[$methodKey] ? '_' . $this->replacedReservedMethods[$methodKey] : '');
            } else {
                return '_' . $methodName;
            }
        } else {
            return $methodName;
        }
    }
    /**
     * Static method wich returns a unique name case sensitively
     * Useful to name methods case sensitively distinct, see http://the-echoplex.net/log/php-case-sensitivity
     * @param string $name the original name
     * @param string $context the context where the name is needed unique
     * @return string
     */
    protected static function uniqueName($name, $context)
    {
        $insensitiveKey = strtolower($name . '_' . $context);
        $sensitiveKey = $name . '_' . $context;
        if (array_key_exists($sensitiveKey, self::$uniqueNames)) {
            return self::$uniqueNames[$sensitiveKey];
        } elseif (!array_key_exists($insensitiveKey, self::$uniqueNames)) {
            self::$uniqueNames[$insensitiveKey] = 0;
        } else {
            self::$uniqueNames[$insensitiveKey]++;
        }
        $uniqueName = $name . (self::$uniqueNames[$insensitiveKey] ? '_' . self::$uniqueNames[$insensitiveKey] : '');
        self::$uniqueNames[$sensitiveKey] = $uniqueName;
        return $uniqueName;
    }
    /**
     * Gives the availability for test purpose and multiple package generation to purge unique names
     */
    public static function purgeUniqueNames()
    {
        self::$uniqueNames = array();
    }
    /**
     * Gives the availability for test purpose and multiple package generation to purge reserved keywords usage
     */
    public static function purgePhpReservedKeywords()
    {
        self::$replacedPhpReservedKeywords = array();
    }
}


1			<?php
2
3			namespace WsdlToPhp\PackageGenerator\Model;
4
5			use WsdlToPhp\PackageGenerator\ConfigurationReader\GeneratorOptions;
6			use WsdlToPhp\PackageGenerator\ConfigurationReader\PhpReservedKeyword;
7			use WsdlToPhp\PackageGenerator\ConfigurationReader\AbstractReservedWord;
8			use WsdlToPhp\PackageGenerator\Generator\Generator;
9			use WsdlToPhp\PackageGenerator\Generator\Utils as GeneratorUtils;
10			use WsdlToPhp\PackageGenerator\Generator\AbstractGeneratorAware;
11
12			/**
13			* Class AbstractModel defines the basic properties and methods to operations and structs extracted from the WSDL
14			*/
15			abstract class AbstractModel extends AbstractGeneratorAware
16			{
17			/**
18			* Constant used to define the key to store documentation value in meta
19			* @var string
20			*/
21			const META_DOCUMENTATION = 'documentation';
22			/**
23			* Original name od the element
24			* @var string
25			*/
26			private $name = '';
27			/**
28			* Values associated to the operation
29			* @var string[]
30			*/
31			private $meta = array();
32			/**
33			* Define the inheritance of a struct by the name of the parent struct or type
34			* @var string
35			*/
36			private $inheritance = '';
37			/**
38			* Store the object which owns the current model
39			* @var AbstractModel
40			*/
41			private $owner = null;
42			/**
43			* Indicates that the current elemen is an abstract element.
44			* It allows to generated an abstract class.
45			* This will happen for element/complexType that are defined with abstract="true"
46			* @var bool
47			*/
48			private $isAbstract = false;
49			/**
50			* Replaced keywords time in order to generate unique new keyword
51			* @var array
52			*/
53			private static $replacedPhpReservedKeywords = array();
54			/**
55			* Replaced methods time in order to generate unique new method
56			* @var array
57			*/
58			private $replacedReservedMethods = array();
59			/**
60			* Unique name generated in order to ensure unique naming (for struct constructor and setters/getters even for different case attribute name whith same value)
61			* @var array
62			*/
63			private static $uniqueNames = array();
64			/**
65			* Main constructor
66			* @uses AbstractModel::setName()
67			* @param Generator $generator
68			* @param string $name the original name
69			*/
70			public function __construct(Generator $generator, $name)
71			{
72			parent::__construct($generator);
73			$this->setName($name);
74			}
75			/**
76			* @uses AbstractModel::getInheritedModel()
77			* @uses AbstractModel::getPackagedName()
78			* @uses AbstractModel::getExtends()
79			* @uses Struct::isStruct()
80			* @return string
81			*/
82			public function getExtendsClassName()
83			{
84			$extends = '';
85			if (($model = $this->getInheritedModel()) instanceof Struct && $model->isStruct()) {
86			$extends = $model->getPackagedName($model->isRestriction());
87			}
88			if (empty($extends)) {
89			$extends = $this->getExtends(true);
90			}
91			return $extends;
92			}
93			/**
94			* Returns the name of the class the current class inherits from
95			* @return string
96			*/
97			public function getInheritance()
98			{
99			return $this->inheritance;
100			}
101			/**
102			* Sets the name of the class the current class inherits from
103			* @param string $inheritance
104			* @return AbstractModel
105			*/
106			public function setInheritance($inheritance = '')
107			{
108			$this->inheritance = $inheritance;
109			return $this;
110			}
111			/**
112			* @uses AbstractGeneratorAware::getGenerator()
113			* @uses Generator::getStruct()
114			* @uses AbstractModel::getInheritance()
115			* @return Struct
116			*/
117			public function getInheritedModel()
118			{
119			return $this->getGenerator()->getStruct($this->getInheritance());
120			}
121			/**
122			* Returns the meta
123			* @return string[]
124			*/
125			public function getMeta()
126			{
127			return $this->meta;
128			}
129			/**
130			* Sets the meta
131			* @param string[] $meta
132			* @return AbstractModel
133			*/
134			public function setMeta(array $meta = array())
135			{
136			$this->meta = $meta;
137			return $this;
138			}
139			/**
140			* Add meta information to the operation
141			* @uses AbstractModel::getMeta()
142			* @throws \InvalidArgumentException
143			* @param string $metaName
144			* @param mixed $metaValue
145			* @return AbstractModel
146			*/
147			public function addMeta($metaName, $metaValue)
148			{
149			if (!is_scalar($metaName) \|\| (!is_scalar($metaValue) && !is_array($metaValue))) {
150			throw new \InvalidArgumentException(sprintf('Invalid meta name "%s" or value "%s". Please provide scalar meta name and scalar or array meta value.', gettype($metaName), gettype($metaValue)), __LINE__);
151			}
152			$metaValue = is_scalar($metaValue) ? trim($metaValue) : $metaValue;
153			if ((is_scalar($metaValue) && $metaValue !== '') \|\| is_array($metaValue)) {
154			if (!array_key_exists($metaName, $this->meta)) {
155			$this->meta[$metaName] = $metaValue;
156			} elseif (is_array($this->meta[$metaName]) && is_array($metaValue)) {
157			$this->meta[$metaName] = array_merge($this->meta[$metaName], $metaValue);
158			} elseif (is_array($this->meta[$metaName])) {
159			array_push($this->meta[$metaName], $metaValue);
160			} else {
161			$this->meta[$metaName] = $metaValue;
162			}
163			ksort($this->meta);
164			}
165			return $this;
166			}
167			/**
168			* Sets the documentation meta value.
169			* Documentation is set as an array so if multiple documentation nodes are set for an unique element, it will gather them.
170			* @uses AbstractModel::META_DOCUMENTATION
171			* @uses AbstractModel::addMeta()
172			* @param string $documentation the documentation from the WSDL
173			* @return AbstractModel
174			*/
175			public function setDocumentation($documentation)
176			{
177			return $this->addMeta(self::META_DOCUMENTATION, is_array($documentation) ? $documentation : array(
178			$documentation,
179			));
180			}
181			/**
182			* Returns a meta value according to its name
183			* @uses AbstractModel::getMeta()
184			* @param string $metaName the meta information name
185			* @param mixed $fallback the fallback value if unset
186			* @return mixed the meta information value
187			*/
188			public function getMetaValue($metaName, $fallback = null)
189			{
190			$meta = $this->getMeta();
191			return array_key_exists($metaName, $meta) ? $meta[$metaName] : $fallback;
192			}
193			/**
194			* Returns the value of the first meta value assigned to the name
195			* @param string[] $names the meta names to check
196			* @param mixed $fallback the fallback value if anyone is set
197			* @return mixed the meta information value
198			*/
199			public function getMetaValueFirstSet(array $names, $fallback = null)
200			{
201			$meta = $this->getMeta();
202			foreach ($names as $name) {
203			if (array_key_exists($name, $meta)) {
204			return $meta[$name];
205			}
206			}
207			return $fallback;
208			}
209			/**
210			* Returns the original name extracted from the WSDL
211			* @return string
212			*/
213			public function getName()
214			{
215			return $this->name;
216			}
217			/**
218			* Sets the original name extracted from the WSDL
219			* @param string $name
220			* @return AbstractModel
221			*/
222			public function setName($name)
223			{
224			$this->name = $name;
225			return $this;
226			}
227			/**
228			* Returns a valid clean name for PHP
229			* @uses AbstractModel::getName()
230			* @uses AbstractModel::cleanString()
231			* @param bool $keepMultipleUnderscores optional, allows to keep the multiple consecutive underscores
232			* @return string
233			*/
234			public function getCleanName($keepMultipleUnderscores = true)
235			{
236			return self::cleanString($this->getName(), $keepMultipleUnderscores);
237			}
238			/**
239			* Returns the owner model object
240			* @return AbstractModel
241			*/
242			public function getOwner()
243			{
244			return $this->owner;
245			}
246			/**
247			* Sets the owner model object
248			* @param AbstractModel $owner object the owner of the current model
249			* @return AbstractModel
250			*/
251			public function setOwner(AbstractModel $owner)
252			{
253			$this->owner = $owner;
254			return $this;
255			}
256			/**
257			* @return bool
258			*/
259			public function isAbstract()
260			{
261			return $this->isAbstract;
262			}
263			/**
264			* @param bool $isAbstract
265			* @return AbstractModel
266			*/
267			public function setAbstract($isAbstract)
268			{
269			$this->isAbstract = $isAbstract;
270			return $this;
271			}
272			/**
273			* Returns true if the original name is safe to use as a PHP property, variable name or class name
274			* @uses AbstractModel::getName()
275			* @uses AbstractModel::getCleanName()
276			* @return bool
277			*/
278			public function nameIsClean()
279			{
280			return ($this->getName() !== '' && $this->getName() === $this->getCleanName());
281			}
282			/**
283			* Returns the packaged name
284			* @uses AbstractModel::getNamespace()
285			* @uses AbstractModel::getCleanName()
286			* @uses AbstractModel::getContextualPart()
287			* @uses AbstractModel::uniqueName()
288			* @uses AbstractModel::replacePhpReservedKeyword()
289			* @uses AbstractGeneratorAware::getGenerator()
290			* @uses Generator::getOptionPrefix()
291			* @uses Generator::getOptionSuffix()
292			* @uses AbstractModel::uniqueName() to ensure unique naming of struct case sensitively
293			* @return string
294			*/
295			public function getPackagedName($namespaced = false)
296			{
297			$nameParts = array();
298			if ($namespaced && $this->getNamespace() !== '') {
299			$nameParts[] = sprintf('\%s\\', $this->getNamespace());
300			}
301			$cleanName = $this->getCleanName();
302			if ($this->getGenerator()->getOptionPrefix() !== '') {
303			$nameParts[] = $this->getGenerator()->getOptionPrefix();
304			} else {
305			$cleanName = self::replacePhpReservedKeyword($cleanName);
306			}
307			$nameParts[] = ucfirst(self::uniqueName($cleanName, $this->getContextualPart()));
308			if ($this->getGenerator()->getOptionSuffix() !== '') {
309			$nameParts[] = $this->getGenerator()->getOptionSuffix();
310			}
311			return implode('', $nameParts);
312			}
313			/**
314			* Allows to define the contextual part of the class name for the package
315			* @return string
316			*/
317			public function getContextualPart()
318			{
319			return '';
320			}
321			/**
322			* Allows to define from which class the curent model extends
323			* @param bool $short
324			* @return string\|null
325			*/
326			public function getExtends($short = false)
327			{
328			return '';
329			}
330			/**
331			* @uses AbstractGeneratorAware::getGenerator()
332			* @uses Generator::getOptionNamespacePrefix()
333			* @uses Generator::getOptionPrefix()
334			* @uses Generator::getOptionSuffix()
335			* @uses AbstractModel::getSubDirectory()
336			* @return string
337			*/
338			public function getNamespace()
339			{
340			$namespaces = array();
341			$namespace = $this->getGenerator()->getOptionNamespacePrefix();
342			if (empty($namespace)) {
343			if ($this->getGenerator()->getOptionPrefix() !== '') {
344			$namespaces[] = $this->getGenerator()->getOptionPrefix();
345			} elseif ($this->getGenerator()->getOptionSuffix() !== '') {
346			$namespaces[] = $this->getGenerator()->getOptionSuffix();
347			}
348			} else {
349			$namespaces[] = $namespace;
350			}
351			if ($this->getSubDirectory() !== '') {
352			$namespaces[] = $this->getSubDirectory();
353			}
354			return implode('\\', $namespaces);
355			}
356			/**
357			* Returns directory where to store class and create it if needed
358			* @uses AbstractGeneratorAware::getGenerator()
359			* @uses AbstractModel::getOptionCategory()
360			* @uses AbstractGeneratorAware::getContextualPart()
361			* @uses GeneratorOptions::VALUE_CAT
362			* @return string
363			*/
364			public function getSubDirectory()
365			{
366			$subDirectory = '';
367			if ($this->getGenerator()->getOptionCategory() === GeneratorOptions::VALUE_CAT) {
368			$subDirectory = $this->getContextualPart();
369			}
370			return $subDirectory;
371			}
372			/**
373			* Returns the sub package name which the model belongs to
374			* Must be overridden by sub classes
375			* @return array
376			*/
377			public function getDocSubPackages()
378			{
379			return array();
380			}
381			/**
382			* Clean a string to make it valid as PHP variable
383			* @uses GeneratorUtils::cleanString()
384			* @param string $string the string to clean
385			* @param bool $keepMultipleUnderscores optional, allows to keep the multiple consecutive underscores
386			* @return string
387			*/
388			public static function cleanString($string, $keepMultipleUnderscores = true)
389			{
390			return GeneratorUtils::cleanString($string, $keepMultipleUnderscores);
391			}
392			/**
393			* Returns a usable keyword for a original keyword
394			* @uses PhpReservedKeyword::instance()
395			* @uses PhpReservedKeyword::is()
396			* @param string $keyword the keyword
397			* @param string $context the context
398			* @return string
399			*/
400			public static function replacePhpReservedKeyword($keyword, $context = null)
401			{
402			if (PhpReservedKeyword::instance()->is($keyword)) {
403			if ($context !== null) {
404			$keywordKey = $keyword . '_' . $context;
405			if (!array_key_exists($keywordKey, self::$replacedPhpReservedKeywords)) {
406			self::$replacedPhpReservedKeywords[$keywordKey] = 0;
407			} else {
408			self::$replacedPhpReservedKeywords[$keywordKey]++;
409			}
410			return '_' . $keyword . (self::$replacedPhpReservedKeywords[$keywordKey] ? '_' . self::$replacedPhpReservedKeywords[$keywordKey] : '');
411			} else {
412			return '_' . $keyword;
413			}
414			} else {
415			return $keyword;
416			}
417			}
418			/**
419			* @throws \InvalidArgumentException
420			* @param $filename
421			* @return AbstractReservedWord
422			*/
423			public function getReservedMethodsInstance($filename = null)
424			{
425			throw new \InvalidArgumentException(sprintf('The method %s should be defined in the class %s', __FUNCTION__, get_called_class(), __LINE__));
426			}
427			/**
428			* Returns a usable method for a original method
429			* @uses PhpReservedKeywords::instance()
430			* @uses PhpReservedKeywords::is()
431			* @param string $methodName the method name
432			* @param string $context the context
433			* @return string
434			*/
435			public function replaceReservedMethod($methodName, $context = null)
436			{
437			if ($this->getReservedMethodsInstance()->is($methodName)) {
438			if ($context !== null) {
439			$methodKey = $methodName . '_' . $context;
440			if (!array_key_exists($methodKey, $this->replacedReservedMethods)) {
441			$this->replacedReservedMethods[$methodKey] = 0;
442			} else {
443			$this->replacedReservedMethods[$methodKey]++;
444			}
445			return '_' . $methodName . ($this->replacedReservedMethods[$methodKey] ? '_' . $this->replacedReservedMethods[$methodKey] : '');
446			} else {
447			return '_' . $methodName;
448			}
449			} else {
450			return $methodName;
451			}
452			}
453			/**
454			* Static method wich returns a unique name case sensitively
455			* Useful to name methods case sensitively distinct, see http://the-echoplex.net/log/php-case-sensitivity
456			* @param string $name the original name
457			* @param string $context the context where the name is needed unique
458			* @return string
459			*/
460			protected static function uniqueName($name, $context)
461			{
462			$insensitiveKey = strtolower($name . '_' . $context);
463			$sensitiveKey = $name . '_' . $context;
464			if (array_key_exists($sensitiveKey, self::$uniqueNames)) {
465			return self::$uniqueNames[$sensitiveKey];
466			} elseif (!array_key_exists($insensitiveKey, self::$uniqueNames)) {
467			self::$uniqueNames[$insensitiveKey] = 0;
468			} else {
469			self::$uniqueNames[$insensitiveKey]++;
470			}
471			$uniqueName = $name . (self::$uniqueNames[$insensitiveKey] ? '_' . self::$uniqueNames[$insensitiveKey] : '');
472			self::$uniqueNames[$sensitiveKey] = $uniqueName;
473			return $uniqueName;
474			}
475			/**
476			* Gives the availability for test purpose and multiple package generation to purge unique names
477			*/
478			public static function purgeUniqueNames()
479			{
480			self::$uniqueNames = array();
481			}
482			/**
483			* Gives the availability for test purpose and multiple package generation to purge reserved keywords usage
484			*/
485			public static function purgePhpReservedKeywords()
486			{
487			self::$replacedPhpReservedKeywords = array();
488			}
489			}
490

WsdlToPhp / PackageGenerator

Push — feature/issue-92 ( 67f652...bf7282 )

AbstractModel::getExtendsClassName() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like