DataObjectAnnotator::writeFileContent() - Code Metrics - Inspection of "FIX Update Scrutinizer configuration" - silverleague/silverstripe-ideannotator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#98)

by Robbie

created 2017-10-16 04:05 UTC

DataObjectAnnotator::writeFileContent() B

↳ Parent: DataObjectAnnotator

Complexity

Conditions	7
Paths	4

Size

Total Lines	17
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	7
eloc	12
nc	4
nop	1
dl	0
loc	17
rs	8.2222
c	0
b	0
f	0

<?php

namespace SilverLeague\IDEAnnotator;

use Psr\Container\NotFoundExceptionInterface;
use ReflectionException;
use SilverStripe\Control\Director;
use SilverStripe\Core\ClassInfo;
use SilverStripe\Core\Config\Configurable;
use SilverStripe\Core\Extensible;
use SilverStripe\Core\Injector\Injectable;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\ORM\DB;

/**
 * Class DataObjectAnnotator
 * Generates phpdoc annotations for database fields and orm relations
 * so IDE's with autocompletion and property inspection will recognize properties and relation methods.
 *
 * The annotations can be generated with dev/build with @see Annotatable
 * and from the @see DataObjectAnnotatorTask
 *
 * The generation is disabled by default.
 * It is advisable to only enable it in your local dev environment,
 * so the files won't change on a production server when you run dev/build
 *
 * @package IDEAnnotator/Core
 */
class DataObjectAnnotator
{
    use Injectable;
    use Configurable;
    use Extensible;

    /**
     * @config
     * Enable generation from @see Annotatable and @see DataObjectAnnotatorTask
     * @var bool
     */
    private static $enabled = false;


    /**
     * @config
     * Enable modules that are allowed to have generated docblocks for DataObjects and DataExtensions
     * @var array
     */
    private static $enabled_modules = ['mysite'];


    /**
     * @var AnnotatePermissionChecker
     */
    private $permissionChecker;

    /**
     * @var array
     */
    private $annotatableClasses = [];

    /**
     * DataObjectAnnotator constructor.
     * @throws NotFoundExceptionInterface
     */
    public function __construct()
    {
        // Don't instantiate anything if annotations are not enabled.
        if (static::config()->get('enabled') === true && Director::isDev()) {
            $this->permissionChecker = Injector::inst()->get(AnnotatePermissionChecker::class);
            foreach ($this->permissionChecker->getSupportedParentClasses() as $supportedParentClass) {
                $this->setEnabledClasses($supportedParentClass);
            }
        }
    }

    /**
     * Get all annotatable classes from enabled modules
     */
    protected function setEnabledClasses($supportedParentClass)
    {
        foreach ((array)ClassInfo::subclassesFor($supportedParentClass) as $class) {
            $classInfo = new AnnotateClassInfo($class);
            if ($this->permissionChecker->moduleIsAllowed($classInfo->getModuleName())) {
                $this->annotatableClasses[$class] = $classInfo->getClassFilePath();
            }
        }
    }

    /**
     * @return boolean
     */
    public static function isEnabled()
    {
        return (bool)static::config()->get('enabled');
    }

    /**
     * Generate docblock for all subclasses of DataObjects and DataExtenions
     * within a module.
     *
     * @param string $moduleName
     * @return bool
     */
    public function annotateModule($moduleName)
    {
        if (!(bool)$moduleName || !$this->permissionChecker->moduleIsAllowed($moduleName)) {
            return false;
        }

        $classes = (array)$this->getClassesForModule($moduleName);

        foreach ($classes as $className => $filePath) {
            $this->annotateObject($className);
        }

        return true;
    }

    /**
     * @param $moduleName
     * @return array
     * @throws ReflectionException
     */
    public function getClassesForModule($moduleName)
    {
        $classes = [];

        foreach ($this->annotatableClasses as $class => $filePath) {
            $classInfo = new AnnotateClassInfo($class);
            if ($moduleName === $classInfo->getModuleName()) {
                $classes[$class] = $filePath;
            }
        }

        return $classes;
    }

    /**
     * Generate docblock for a single subclass of DataObject or DataExtenions
     *
     * @param string $className
     * @return bool
     * @throws ReflectionException
     */
    public function annotateObject($className)
    {
        if (!$this->permissionChecker->classNameIsAllowed($className)) {
            return false;
        }

        $this->writeFileContent($className);

        return true;
    }

    /**
     * @param string $className
     * @throws ReflectionException
     */
    protected function writeFileContent($className)
    {
        $classInfo = new AnnotateClassInfo($className);
        $filePath = $classInfo->getClassFilePath();

        if (!is_writable($filePath)) {
            DB::alteration_message($className . ' is not writable by ' . get_current_user(), 'error');
        } else {
            $original = file_get_contents($filePath);
            $generated = $this->getGeneratedFileContent($original, $className);

            // we have a change, so write the new file
            if ($generated && $generated !== $original && $className) {
                file_put_contents($filePath, $generated);
                DB::alteration_message($className . ' Annotated', 'created');
            } elseif ($generated === $original && $className) {
                DB::alteration_message($className);
            }
        }
    }

    /**
     * Return the complete File content with the newly generated DocBlocks
     *
     * @param string $fileContent
     * @param string $className
     * @return mixed
     * @throws ReflectionException
     */
    protected function getGeneratedFileContent($fileContent, $className)
    {
        $generator = new DocBlockGenerator($className);

        $existing = $generator->getExistingDocBlock();
        $generated = $generator->getGeneratedDocBlock();

        if ($existing) {
            $fileContent = str_replace($existing, $generated, $fileContent);
        } else {
            $needle = "class {$className}";
            $replace = "{$generated}\nclass {$className}";
            $pos = strpos($fileContent, $needle);
            if ($pos !== false) {
                $fileContent = substr_replace($fileContent, $replace, $pos, strlen($needle));
            } else {
                if (strrpos($className, "\\") !== false && class_exists($className)) {
                    $exploded = explode("\\", $className);
                    $classNameNew = end($exploded);
                    $needle = "class {$classNameNew}";
                    $replace = "{$generated}\nclass {$classNameNew}";
                    $pos = strpos($fileContent, $needle);
                    $fileContent = substr_replace($fileContent, $replace, $pos, strlen($needle));
                    DB::alteration_message('Found namespaced Class: ' . $classNameNew);
                } else {
                    DB::alteration_message(
                        "Could not find string 'class $className'. Please check casing and whitespace.",
                        'error'
                    );
                }
            }
        }

        return $fileContent;
    }
}


1			<?php
2
3			namespace SilverLeague\IDEAnnotator;
4
5			use Psr\Container\NotFoundExceptionInterface;
6			use ReflectionException;
7			use SilverStripe\Control\Director;
8			use SilverStripe\Core\ClassInfo;
9			use SilverStripe\Core\Config\Configurable;
10			use SilverStripe\Core\Extensible;
11			use SilverStripe\Core\Injector\Injectable;
12			use SilverStripe\Core\Injector\Injector;
13			use SilverStripe\ORM\DB;
14
15			/**
16			* Class DataObjectAnnotator
17			* Generates phpdoc annotations for database fields and orm relations
18			* so IDE's with autocompletion and property inspection will recognize properties and relation methods.
19			*
20			* The annotations can be generated with dev/build with @see Annotatable
21			* and from the @see DataObjectAnnotatorTask
22			*
23			* The generation is disabled by default.
24			* It is advisable to only enable it in your local dev environment,
25			* so the files won't change on a production server when you run dev/build
26			*
27			* @package IDEAnnotator/Core
28			*/
29			class DataObjectAnnotator
30			{
31			use Injectable;
32			use Configurable;
33			use Extensible;
34
35			/**
36			* @config
37			* Enable generation from @see Annotatable and @see DataObjectAnnotatorTask
38			* @var bool
39			*/
40			private static $enabled = false;
			1 ignored issue – show Unused Code introduced 2017-04-30 09:28 UTC by Report Bug Copy Issue Report The property `$enabled` is not used and could be removed. This check marks private properties in classes that are never used. Those properties can be removed. Loading history...
41
42			/**
43			* @config
44			* Enable modules that are allowed to have generated docblocks for DataObjects and DataExtensions
45			* @var array
46			*/
47			private static $enabled_modules = ['mysite'];
			1 ignored issue – show Unused Code introduced 2017-10-16 04:00 UTC by Report Bug Copy Issue Report The property `$enabled_modules` is not used and could be removed. This check marks private properties in classes that are never used. Those properties can be removed. Loading history...
48
49			/**
50			* @var AnnotatePermissionChecker
51			*/
52			private $permissionChecker;
53
54			/**
55			* @var array
56			*/
57			private $annotatableClasses = [];
58
59			/**
60			* DataObjectAnnotator constructor.
61			* @throws NotFoundExceptionInterface
62			*/
63			public function __construct()
64			{
65			// Don't instantiate anything if annotations are not enabled.
66			if (static::config()->get('enabled') === true && Director::isDev()) {
67			$this->permissionChecker = Injector::inst()->get(AnnotatePermissionChecker::class);
68			foreach ($this->permissionChecker->getSupportedParentClasses() as $supportedParentClass) {
69			$this->setEnabledClasses($supportedParentClass);
70			}
71			}
72			}
73
74			/**
75			* Get all annotatable classes from enabled modules
76			*/
77			protected function setEnabledClasses($supportedParentClass)
78			{
79			foreach ((array)ClassInfo::subclassesFor($supportedParentClass) as $class) {
80			$classInfo = new AnnotateClassInfo($class);
81			if ($this->permissionChecker->moduleIsAllowed($classInfo->getModuleName())) {
82			$this->annotatableClasses[$class] = $classInfo->getClassFilePath();
83			}
84			}
85			}
86
87			/**
88			* @return boolean
89			*/
90			public static function isEnabled()
91			{
92			return (bool)static::config()->get('enabled');
93			}
94
95			/**
96			* Generate docblock for all subclasses of DataObjects and DataExtenions
97			* within a module.
98			*
99			* @param string $moduleName
100			* @return bool
101			*/
102			public function annotateModule($moduleName)
103			{
104			if (!(bool)$moduleName \|\| !$this->permissionChecker->moduleIsAllowed($moduleName)) {
105			return false;
106			}
107
108			$classes = (array)$this->getClassesForModule($moduleName);
109
110			foreach ($classes as $className => $filePath) {
111			$this->annotateObject($className);
112			}
113
114			return true;
115			}
116
117			/**
118			* @param $moduleName
119			* @return array
120			* @throws ReflectionException
121			*/
122			public function getClassesForModule($moduleName)
123			{
124			$classes = [];
125
126			foreach ($this->annotatableClasses as $class => $filePath) {
127			$classInfo = new AnnotateClassInfo($class);
128			if ($moduleName === $classInfo->getModuleName()) {
129			$classes[$class] = $filePath;
130			}
131			}
132
133			return $classes;
134			}
135
136			/**
137			* Generate docblock for a single subclass of DataObject or DataExtenions
138			*
139			* @param string $className
140			* @return bool
141			* @throws ReflectionException
142			*/
143			public function annotateObject($className)
144			{
145			if (!$this->permissionChecker->classNameIsAllowed($className)) {
146			return false;
147			}
148
149			$this->writeFileContent($className);
150
151			return true;
152			}
153
154			/**
155			* @param string $className
156			* @throws ReflectionException
157			*/
158			protected function writeFileContent($className)
159			{
160			$classInfo = new AnnotateClassInfo($className);
161			$filePath = $classInfo->getClassFilePath();
162
163			if (!is_writable($filePath)) {
164			DB::alteration_message($className . ' is not writable by ' . get_current_user(), 'error');
165			} else {
166			$original = file_get_contents($filePath);
167			$generated = $this->getGeneratedFileContent($original, $className);
168
169			// we have a change, so write the new file
170			if ($generated && $generated !== $original && $className) {
171			file_put_contents($filePath, $generated);
172			DB::alteration_message($className . ' Annotated', 'created');
173			} elseif ($generated === $original && $className) {
174			DB::alteration_message($className);
175			}
176			}
177			}
178
179			/**
180			* Return the complete File content with the newly generated DocBlocks
181			*
182			* @param string $fileContent
183			* @param string $className
184			* @return mixed
185			* @throws ReflectionException
186			*/
187			protected function getGeneratedFileContent($fileContent, $className)
188			{
189			$generator = new DocBlockGenerator($className);
190
191			$existing = $generator->getExistingDocBlock();
192			$generated = $generator->getGeneratedDocBlock();
193
194			if ($existing) {
195			$fileContent = str_replace($existing, $generated, $fileContent);
196			} else {
197			$needle = "class {$className}";
198			$replace = "{$generated}\nclass {$className}";
199			$pos = strpos($fileContent, $needle);
200			if ($pos !== false) {
201			$fileContent = substr_replace($fileContent, $replace, $pos, strlen($needle));
202			} else {
203			if (strrpos($className, "\\") !== false && class_exists($className)) {
204			$exploded = explode("\\", $className);
205			$classNameNew = end($exploded);
206			$needle = "class {$classNameNew}";
207			$replace = "{$generated}\nclass {$classNameNew}";
208			$pos = strpos($fileContent, $needle);
209			$fileContent = substr_replace($fileContent, $replace, $pos, strlen($needle));
210			DB::alteration_message('Found namespaced Class: ' . $classNameNew);
211			} else {
212			DB::alteration_message(
213			"Could not find string 'class $className'. Please check casing and whitespace.",
214			'error'
215			);
216			}
217			}
218			}
219
220			return $fileContent;
221			}
222			}
223

silverleague / silverstripe-ideannotator

Pull Request — master (#98)

DataObjectAnnotator::writeFileContent() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like