TDMCreateFile - Code Metrics - Inspection of "Merge pull request #76 from txmodxoops/timgno" - txmodxoops/tdmcreate - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — master (31be8b)

by Gino

created 2016-02-14 21:22 UTC

TDMCreateFile C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	607
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Metric	Value
wmc	55
lcom	2
cbo	3
dl	0
loc	607
rs	6.7172

33 Methods

Rating	Name	Size	Complexity
A	__construct()	6	1
A	getInstance()	9	2
B	create()	14	5
A	write()	5	1
A	setRepositoryPath()	4	1
A	getRepositoryPath()	4	1
A	setSubDir()	4	1
A	getSubDir()	4	1
A	setFileName()	4	1
A	getFileName()	4	1
A	setContent()	4	1
A	getContent()	4	1
A	getFolderName()	14	3
A	getUploadPath()	10	2
A	getCreated()	4	1
A	getNotCreated()	4	1
A	setMode()	4	1
A	getMode()	4	1
A	getLanguage()	12	4
A	getLeftString()	4	1
A	getRightString()	13	3
A	getCamelCase()	13	3
A	getUcfirst()	4	1
A	getLcfirst()	4	1
A	getStrToUpper()	4	1
A	getStrToLower()	4	1
A	getInclude()	4	1
A	getIncludeOnce()	4	1
A	getCommentLine()	7	2
A	getHeaderComment()	4	1
A	getSimpleString()	4	1
B	getHeaderFilesComments()	36	3
B	renderFile()	35	5

How to fix Complexity

<?php


/*
 You may not change or alter any portion of this comment or credits
 of supporting developers from this source code or any supporting source code
 which is considered copyrighted (c) material of the original comment or credit authors.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 */
/**
 * tdmcreate module.
 *
 * @copyright       The XOOPS Project http://sourceforge.net/projects/xoops/
 * @license         GNU GPL 2 (http://www.gnu.org/licenses/old-licenses/gpl-2.0.html)
 *
 * @since           2.5.0
 *
 * @author          Txmod Xoops http://www.txmodxoops.org
 *
 * @version         $Id: TDMCreateFile.php 12258 2014-01-02 09:33:29Z timgno $
 */
xoops_load('XoopsFile');
/**
 * Class TDMCreateFile.
 */
class TDMCreateFile extends TDMCreateTableFields
namespace YourVendor;

class YourClass { }
{
    /*
    * @var string
    */
    private $xoopsFile = null;

    /**
     * "fileName" attribute of the files.
     *
     * @var mixed
     */
    private $fileName = null;

    /**
     * "subdir" attribute of the directories.
     *
     * @var string
     */
    private $subdir = null;

    /**
     * "uploadPath" attribute of the files.
     *
     * @var string
     */
    private $uploadPath = null;

    /*
    * @var string
    */
    private $content = null;

    /*
    * @var mixed
    */
    private $created = null;

    /*
    * @var mixed
    */
    private $notCreated = null;

    /*
    * @var string
    */
    private $mode = null;

    /*
    * @var string
    */
    protected $phpcode = null;

    /*
    * @var string
    */
    private $tdmcreate = null;

    /*
    *  @public function constructor
    *  @param null
    */
    /**
     *
     */
    public function __construct()
    {
        parent::__construct();
        $this->xoopsFile = XoopsFile::getHandler();
        $this->tdmcreate = TDMCreateHelper::getInstance();

    }

    /*
    *  @public static function &getInstance
    *  @param null
    */
    /**
     * @return TDMCreateFile
     */
    public static function &getInstance()
    {
        static $instance = false;
        if (!$instance) {
            $instance = new self();
        }

        return $instance;
    }

    /**
     * @public function create
     *
     * @param $moduleDirname
     * @param $subdir
     * @param $fileName
     * @param $content
     * @param $created
     * @param $notCreated
     * @param $mode
     */
    public function create($moduleDirname, $subdir = null, $fileName = null, $content = '', $created = null, $notCreated = null, $mode = 'w+')
    {
        $this->setFileName($fileName);
        $this->created = $created;
        $this->notCreated = $notCreated;
        $this->setMode($mode);
        $this->setRepositoryPath($moduleDirname);
        if (!empty($content) && is_string($content)) {
            $this->setContent($content);
        }
        if (isset($subdir) && is_string($subdir)) {
            $this->setSubDir($subdir);
        }
    }

    /*
    *  @public function write
    *  @param string $module
    *  @param string $fileName
    */
    /**
     * @param $module
     * @param $fileName
     */
    public function write($module, $fileName)
    {
        $this->setModule($module);
        $this->setFileName($fileName);
    }

    /*
    *  @private function setRepositoryPath
    *  @param string $moduleDirname
    */
    /**
     * @param $moduleDirname
     */
    private function setRepositoryPath($moduleDirname)
    {
        $this->uploadPath = TDMC_UPLOAD_REPOSITORY_PATH.'/'.$moduleDirname;
    }

    /*
    *  @private function getRepositoryPath
    *  @param null
    */
    /**
     * @return string
     */
    private function getRepositoryPath()
    {
        return $this->uploadPath;
    }

    /*
    *  @private function setSubDir
    *  @param string $subdir
    */
    /**
     * @param $subdir
     */
    private function setSubDir($subdir)
    {
        $this->subdir = $subdir;
    }

    /*
    *  @private function getSubDir
    *  @param null
    */
    private function getSubDir()
    {
        return $this->subdir;
    }

    /**
     * public function setFileName.
     *
     * @param $fileName
     *
     * @internal param mixed $file_name
     */
    public function setFileName($fileName)
    {
        $this->fileName = $fileName;
    }

    /*
    *  @public function getFileName
    *  @param null
    */
    /**
     * @return mixed
     */
    public function getFileName()
    {
        return $this->fileName;
    }

    /*
    *  @private function setContent
    *  @param string $content
    */
    /**
     * @param $content
     */
    private function setContent($content)
    {
        $this->content = $content;
    }

    /*
    *  @private function setContent
    *  @param null
    */
    /**
     */
    private function getContent()
    {
        return $this->content;
    }

    /*
    *  @private function getFolderName
    *  @param null
    */
    /**
     * @return string
     */
    private function getFolderName()
    {
        $path = $this->getUploadPath();
        if (strrpos($path, '\\')) {
            $str = strrpos($path, '\\');
            if ($str !== false) {
                return substr($path, $str + 1, strlen($path));
            } else {
                return substr($path, $str, strlen($path));
            }
        }
        //return 'root module';
        return;
    }

    /*
    *  @public function getUploadPath
    *  @param null
    */
    /**
     * @return string
     */
    private function getUploadPath()
    {
        if ($this->getSubDir() != null) {
            $ret = $this->getRepositoryPath().'/'.$this->getSubDir();
        } else {
            $ret = $this->getRepositoryPath();
        }

        return $ret;
    }

    /*
    *  @private function getCreated
    *  @param null
    */
    /**
     * @return bool
     */
    private function getCreated()
    {
        return $this->created;
    }

    /*
    *  @private function getNotCreated
    *  @param null
    */
    /**
     * @return bool
     */
    private function getNotCreated()
    {
        return $this->notCreated;
    }

    /*
    *  @private function setMode
    *  @param string $mode
    */
    /**
     * @param $mode
     */
    private function setMode($mode)
    {
        $this->mode = $mode;
    }

    /*
    *  @private function getMode
    *  @param null
    */
    /**
     */
    private function getMode()
    {
        return $this->mode;
    }

    /*
    *  @public function getLanguage
    *  @param string $moduleDirname
    *  @param string $prefix
    *  @param string $suffix
    */
    /**
     * @param        $moduleDirname
     * @param string $prefix
     * @param string $suffix
     *
     * @return string
     */
    public function getLanguage($moduleDirname, $prefix = '', $suffix = '')
    {
        $lang = '_'.$prefix.'_'.strtoupper($moduleDirname);
        $ret = $lang;
        if (!empty($suffix) || $suffix != '_') {
            $ret = $lang.'_'.$suffix;
        } elseif ($suffix == '_') {
            $ret = $lang.'_';
        }

        return $ret;
    }

    /*
    *  @public function getLeftString
    *  @param string $string
    */
    /**
     * @param $string
     *
     * @return string
     */
    public function getLeftString($string)
    {
        return substr($string, 0, strpos($string, '_'));
    }

    /*
    *  @public function getRightString
    *  @param string $string
    */
    /**
     * @param $string
     *
     * @return string
     */
    public function getRightString($string)
    {
        if (strpos($string, '_')) {
            $str = strpos($string, '_');
            if ($str !== false) {
                $ret = substr($string, $str + 1, strlen($string));

                return $ret;
            }
        }

        return $string;
    }

    /*
     *  @public function getCamelCase
     *  @param $string
     */
    /**
     * @param $string
     * @param $ucfirst
     * @param $lcfirst
     *
     * @return string
     */
    public function getCamelCase($string, $ucfirst = false, $lcfirst = false)
    {
        $rightString = $this->getRightString($string);
        $leftString = $this->getLeftString($string);
        if ($ucfirst) {
            return $this->getUcfirst($leftString).$this->getUcfirst($rightString);
        }
        if ($lcfirst) {
            return $this->getlcfirst($leftString).$this->getUcfirst($rightString);
        }

        return $string;
    }

    /*
     *  @public function getUcfirst
     *  @param $string
     */
    /**
     * @param $string
     *
     * @return string
     */
    public function getUcfirst($string)
    {
        return ucfirst($string);
    }

    /*
     *  @public function getLcfirst
     *  @param $string
     */
    /**
     * @param $string
     *
     * @return string
     */
    public function getLcfirst($string)
    {
        return lcfirst($string);
    }

    /*
     *  @public function getStrToUpper
     *  @param $string
     */
    /**
     * @param $string
     *
     * @return string
     */
    public function getStrToUpper($string)
    {
        return strtoupper($string);
    }

    /*
     *  @public function getStrToLower
     *  @param $string
     */
    /**
     * @param $string
     *
     * @return string
     */
    public function getStrToLower($string)
    {
        return strtolower($string);
    }

    /*
    *  @public function getInclude
    *  @param $filename
    */
    /**
     * @return string
     */
    public function getInclude($filename = 'header')
    {
        return "include __DIR__ . '/{$filename}.php';\n";
    }

    /*
    *  @public function getIncludeOnce
    *  @param $filename
    */
    /**
     * @return string
     */
    public function getIncludeOnce($filename = 'header')
    {
        return "include_once __DIR__ . '/{$filename}.php';\n";
    }

    /*
     * @public function getCommentLine
     * @param $string     
     * @param $var
     *
     * @return string
     */
    public function getCommentLine($string = '', $var = '')
    {
        $value = !empty($var) ? ' '.$var : '';
        $ret = "// {$string}{$value}\n";

        return $ret;
    }

    /**
     * @private function getHeaderComment
     *
     * @param $comment
     *
     * @return string
     */
    public function getHeaderComment($comment)
    {
        return "// ------------------- {$comment} ------------------- //\n";
    }

    /*
     * @public function getSimpleString
     * @param $string     
     *
     * @return string
     */
    public function getSimpleString($string)
    {
        return "{$string}\n";
    }

    /*
    *  @public function getHeaderFilesComments
    *  @param string $module
    *  @param string $fileName
    */
    /**
     * @param $module
     * @param $fileName
     * @param $noPhpFile
     *
     * @return string
     */
    public function getHeaderFilesComments($module, $fileName, $noPhpFile = null)
    {
        $name = $module->getVar('mod_name');
        $dirname = $module->getVar('mod_dirname');
        $version = $module->getVar('mod_version');
        $since = $module->getVar('mod_since');
        $minXoops = $module->getVar('mod_min_xoops');
        $author = $module->getVar('mod_author');
        $credits = $module->getVar('mod_credits');
        $authorMail = $module->getVar('mod_author_mail');
        $authorWebsiteUrl = $module->getVar('mod_author_website_url');
        $license = $module->getVar('mod_license');
        $subversion = $module->getVar('mod_subversion');
        $date = date('D Y-m-d H:i:s');
        if (is_null($noPhpFile)) {
            $ret = "<?php\n";
            $ret .= "/*\n";
        } elseif (is_string($noPhpFile)) {
            $ret = $noPhpFile;
            $ret .= "/*\n";
        } else {
            $ret .= "/*\n";
function someFunction() {
    $x = 5;
    echo $x;
}
        }
        $filename = TDMC_CLASSES_PATH.'/files/docs/license.txt';
        $handle = fopen($filename, 'rb');
        $data = fread($handle, filesize($filename));
        fclose($handle);
        $ret .= $data."\n";
        $ret .= "*/\n";
        $copyright = array($name => 'module for xoops', '' => '', '@copyright  ' => '   module for xoops', '@license   ' => "    {$license}", '@package   ' => "    {$dirname}",
                            '@since    ' => "     {$since}", '@min_xoops   ' => "  {$minXoops}", '@author    ' => "    {$author} - Email:<{$authorMail}> - Website:<{$authorWebsiteUrl}>",
                            '@version    ' => "   \$Id: {$version} {$fileName} {$subversion} {$date}Z {$credits} \$", );
        $ret .= TDMCreatePhpCode::getInstance()->getPhpCodeCommentMultiLine($copyright);

        return $ret;
    }

    /*
    *  @public function renderFile
    *  @param null
    */
    /**
     * @return string
     */
    public function renderFile()
    {
        $fileName = $this->getFileName();
        $path = $this->getUploadPath().'/'.$fileName;
        $created = $this->getCreated();
        $notCreated = $this->getNotCreated();
        $folderName = $this->getFolderName();
        $mode = $this->getMode();
        $ret = '';
        if (!$this->xoopsFile->__construct($path, true)) {

            // Force to create file if not exist
            if ($this->xoopsFile->open($mode, true)) {

                if ($this->xoopsFile->writable()) {

                    // Integration of the content in the file
                    if (!$this->xoopsFile->write($this->getContent(), $mode, true)) {

                        $ret .= sprintf($notCreated, $fileName, $folderName);
                        $GLOBALS['xoopsTpl']->assign('created', false);
                        exit();
                    }
                    // Created
                    $ret .= sprintf($created, $fileName, $folderName);
                    $GLOBALS['xoopsTpl']->assign('created', true);
                    $this->xoopsFile->close();

                } else {
                    $ret .= sprintf($notCreated, $fileName, $folderName);
                    $GLOBALS['xoopsTpl']->assign('created', false);
                }
            } else {
                $ret .= sprintf($notCreated, $fileName, $folderName);
                $GLOBALS['xoopsTpl']->assign('created', false);
            }
        }

        return $ret;
    }
}


1			<?php
			0 ignored issues – show Coding Style Compatibility introduced 2016-02-04 20:57 UTC by Report Bug Copy Issue Report For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 28 and the first side effect is on line 24. The PSR-1: Basic Coding Standard recommends that a file should either introduce new symbols, that is classes, functions, constants or similar, or have side effects. Side effects are anything that executes logic, like for example printing output, changing ini settings or writing to a file. The idea behind this recommendation is that merely auto-loading a class should not change the state of an application. It also promotes a cleaner style of programming and makes your code less prone to errors, because the logic is not spread out all over the place. To learn more about the PSR-1, please see the PHP-FIG site on the PSR-1. Loading history...
2
3			/*
4			You may not change or alter any portion of this comment or credits
5			of supporting developers from this source code or any supporting source code
6			which is considered copyrighted (c) material of the original comment or credit authors.
7
8			This program is distributed in the hope that it will be useful,
9			but WITHOUT ANY WARRANTY; without even the implied warranty of
10			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11			*/
12			/**
13			* tdmcreate module.
14			*
15			* @copyright The XOOPS Project http://sourceforge.net/projects/xoops/
16			* @license GNU GPL 2 (http://www.gnu.org/licenses/old-licenses/gpl-2.0.html)
17			*
18			* @since 2.5.0
19			*
20			* @author Txmod Xoops http://www.txmodxoops.org
21			*
22			* @version $Id: TDMCreateFile.php 12258 2014-01-02 09:33:29Z timgno $
23			*/
24			xoops_load('XoopsFile');
25			/**
26			* Class TDMCreateFile.
27			*/
28			class TDMCreateFile extends TDMCreateTableFields
			0 ignored issues – show Coding Style Compatibility introduced 2015-12-23 22:08 UTC by Report Bug Copy Issue Report PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions. You can fix this by adding a namespace to your class: namespace YourVendor; class YourClass { } When choosing a vendor namespace, try to pick something that is not too generic to avoid conflicts with other libraries. Loading history...
29			{
30			/*
31			* @var string
32			*/
33			private $xoopsFile = null;
34
35			/**
36			* "fileName" attribute of the files.
37			*
38			* @var mixed
39			*/
40			private $fileName = null;
41
42			/**
43			* "subdir" attribute of the directories.
44			*
45			* @var string
46			*/
47			private $subdir = null;
48
49			/**
50			* "uploadPath" attribute of the files.
51			*
52			* @var string
53			*/
54			private $uploadPath = null;
55
56			/*
57			* @var string
58			*/
59			private $content = null;
60
61			/*
62			* @var mixed
63			*/
64			private $created = null;
65
66			/*
67			* @var mixed
68			*/
69			private $notCreated = null;
70
71			/*
72			* @var string
73			*/
74			private $mode = null;
75
76			/*
77			* @var string
78			*/
79			protected $phpcode = null;
80
81			/*
82			* @var string
83			*/
84			private $tdmcreate = null;
85
86			/*
87			* @public function constructor
88			* @param null
89			*/
90			/**
91			*
92			*/
93			public function __construct()
94			{
95			parent::__construct();
96			$this->xoopsFile = XoopsFile::getHandler();
97			$this->tdmcreate = TDMCreateHelper::getInstance();
			0 ignored issues – show Documentation Bug introduced 2016-01-28 19:04 UTC by Report Bug Copy Issue Report It seems like `\TDMCreateHelper::getInstance()` of type `object<TDMCreateHelper>` is incompatible with the declared type `string` of property `$tdmcreate`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
98			}
99
100			/*
101			* @public static function &getInstance
102			* @param null
103			*/
104			/**
105			* @return TDMCreateFile
106			*/
107			public static function &getInstance()
108			{
109			static $instance = false;
110			if (!$instance) {
111			$instance = new self();
112			}
113
114			return $instance;
115			}
116
117			/**
118			* @public function create
119			*
120			* @param $moduleDirname
121			* @param $subdir
122			* @param $fileName
123			* @param $content
124			* @param $created
125			* @param $notCreated
126			* @param $mode
127			*/
128			public function create($moduleDirname, $subdir = null, $fileName = null, $content = '', $created = null, $notCreated = null, $mode = 'w+')
129			{
130			$this->setFileName($fileName);
131			$this->created = $created;
132			$this->notCreated = $notCreated;
133			$this->setMode($mode);
134			$this->setRepositoryPath($moduleDirname);
135			if (!empty($content) && is_string($content)) {
136			$this->setContent($content);
137			}
138			if (isset($subdir) && is_string($subdir)) {
139			$this->setSubDir($subdir);
140			}
141			}
142
143			/*
144			* @public function write
145			* @param string $module
146			* @param string $fileName
147			*/
148			/**
149			* @param $module
150			* @param $fileName
151			*/
152			public function write($module, $fileName)
153			{
154			$this->setModule($module);
155			$this->setFileName($fileName);
156			}
157
158			/*
159			* @private function setRepositoryPath
160			* @param string $moduleDirname
161			*/
162			/**
163			* @param $moduleDirname
164			*/
165			private function setRepositoryPath($moduleDirname)
166			{
167			$this->uploadPath = TDMC_UPLOAD_REPOSITORY_PATH.'/'.$moduleDirname;
168			}
169
170			/*
171			* @private function getRepositoryPath
172			* @param null
173			*/
174			/**
175			* @return string
176			*/
177			private function getRepositoryPath()
178			{
179			return $this->uploadPath;
180			}
181
182			/*
183			* @private function setSubDir
184			* @param string $subdir
185			*/
186			/**
187			* @param $subdir
188			*/
189			private function setSubDir($subdir)
190			{
191			$this->subdir = $subdir;
192			}
193
194			/*
195			* @private function getSubDir
196			* @param null
197			*/
198			private function getSubDir()
199			{
200			return $this->subdir;
201			}
202
203			/**
204			* public function setFileName.
205			*
206			* @param $fileName
207			*
208			* @internal param mixed $file_name
209			*/
210			public function setFileName($fileName)
211			{
212			$this->fileName = $fileName;
213			}
214
215			/*
216			* @public function getFileName
217			* @param null
218			*/
219			/**
220			* @return mixed
221			*/
222			public function getFileName()
223			{
224			return $this->fileName;
225			}
226
227			/*
228			* @private function setContent
229			* @param string $content
230			*/
231			/**
232			* @param $content
233			*/
234			private function setContent($content)
235			{
236			$this->content = $content;
237			}
238
239			/*
240			* @private function setContent
241			* @param null
242			*/
243			/**
244			*/
245			private function getContent()
246			{
247			return $this->content;
248			}
249
250			/*
251			* @private function getFolderName
252			* @param null
253			*/
254			/**
255			* @return string
256			*/
257			private function getFolderName()
258			{
259			$path = $this->getUploadPath();
260			if (strrpos($path, '\\')) {
261			$str = strrpos($path, '\\');
262			if ($str !== false) {
263			return substr($path, $str + 1, strlen($path));
264			} else {
265			return substr($path, $str, strlen($path));
266			}
267			}
268			//return 'root module';
269			return;
270			}
271
272			/*
273			* @public function getUploadPath
274			* @param null
275			*/
276			/**
277			* @return string
278			*/
279			private function getUploadPath()
280			{
281			if ($this->getSubDir() != null) {
282			$ret = $this->getRepositoryPath().'/'.$this->getSubDir();
283			} else {
284			$ret = $this->getRepositoryPath();
285			}
286
287			return $ret;
288			}
289
290			/*
291			* @private function getCreated
292			* @param null
293			*/
294			/**
295			* @return bool
296			*/
297			private function getCreated()
298			{
299			return $this->created;
300			}
301
302			/*
303			* @private function getNotCreated
304			* @param null
305			*/
306			/**
307			* @return bool
308			*/
309			private function getNotCreated()
310			{
311			return $this->notCreated;
312			}
313
314			/*
315			* @private function setMode
316			* @param string $mode
317			*/
318			/**
319			* @param $mode
320			*/
321			private function setMode($mode)
322			{
323			$this->mode = $mode;
324			}
325
326			/*
327			* @private function getMode
328			* @param null
329			*/
330			/**
331			*/
332			private function getMode()
333			{
334			return $this->mode;
335			}
336
337			/*
338			* @public function getLanguage
339			* @param string $moduleDirname
340			* @param string $prefix
341			* @param string $suffix
342			*/
343			/**
344			* @param $moduleDirname
345			* @param string $prefix
346			* @param string $suffix
347			*
348			* @return string
349			*/
350			public function getLanguage($moduleDirname, $prefix = '', $suffix = '')
351			{
352			$lang = '_'.$prefix.'_'.strtoupper($moduleDirname);
353			$ret = $lang;
354			if (!empty($suffix) \|\| $suffix != '_') {
355			$ret = $lang.'_'.$suffix;
356			} elseif ($suffix == '_') {
357			$ret = $lang.'_';
358			}
359
360			return $ret;
361			}
362
363			/*
364			* @public function getLeftString
365			* @param string $string
366			*/
367			/**
368			* @param $string
369			*
370			* @return string
371			*/
372			public function getLeftString($string)
373			{
374			return substr($string, 0, strpos($string, '_'));
375			}
376
377			/*
378			* @public function getRightString
379			* @param string $string
380			*/
381			/**
382			* @param $string
383			*
384			* @return string
385			*/
386			public function getRightString($string)
387			{
388			if (strpos($string, '_')) {
389			$str = strpos($string, '_');
390			if ($str !== false) {
391			$ret = substr($string, $str + 1, strlen($string));
392
393			return $ret;
394			}
395			}
396
397			return $string;
398			}
399
400			/*
401			* @public function getCamelCase
402			* @param $string
403			*/
404			/**
405			* @param $string
406			* @param $ucfirst
407			* @param $lcfirst
408			*
409			* @return string
410			*/
411			public function getCamelCase($string, $ucfirst = false, $lcfirst = false)
412			{
413			$rightString = $this->getRightString($string);
414			$leftString = $this->getLeftString($string);
415			if ($ucfirst) {
416			return $this->getUcfirst($leftString).$this->getUcfirst($rightString);
417			}
418			if ($lcfirst) {
419			return $this->getlcfirst($leftString).$this->getUcfirst($rightString);
420			}
421
422			return $string;
423			}
424
425			/*
426			* @public function getUcfirst
427			* @param $string
428			*/
429			/**
430			* @param $string
431			*
432			* @return string
433			*/
434			public function getUcfirst($string)
435			{
436			return ucfirst($string);
437			}
438
439			/*
440			* @public function getLcfirst
441			* @param $string
442			*/
443			/**
444			* @param $string
445			*
446			* @return string
447			*/
448			public function getLcfirst($string)
449			{
450			return lcfirst($string);
451			}
452
453			/*
454			* @public function getStrToUpper
455			* @param $string
456			*/
457			/**
458			* @param $string
459			*
460			* @return string
461			*/
462			public function getStrToUpper($string)
463			{
464			return strtoupper($string);
465			}
466
467			/*
468			* @public function getStrToLower
469			* @param $string
470			*/
471			/**
472			* @param $string
473			*
474			* @return string
475			*/
476			public function getStrToLower($string)
477			{
478			return strtolower($string);
479			}
480
481			/*
482			* @public function getInclude
483			* @param $filename
484			*/
485			/**
486			* @return string
487			*/
488			public function getInclude($filename = 'header')
489			{
490			return "include __DIR__ . '/{$filename}.php';\n";
491			}
492
493			/*
494			* @public function getIncludeOnce
495			* @param $filename
496			*/
497			/**
498			* @return string
499			*/
500			public function getIncludeOnce($filename = 'header')
501			{
502			return "include_once __DIR__ . '/{$filename}.php';\n";
503			}
504
505			/*
506			* @public function getCommentLine
507			* @param $string
508			* @param $var
509			*
510			* @return string
511			*/
512			public function getCommentLine($string = '', $var = '')
513			{
514			$value = !empty($var) ? ' '.$var : '';
515			$ret = "// {$string}{$value}\n";
516
517			return $ret;
518			}
519
520			/**
521			* @private function getHeaderComment
522			*
523			* @param $comment
524			*
525			* @return string
526			*/
527			public function getHeaderComment($comment)
528			{
529			return "// ------------------- {$comment} ------------------- //\n";
530			}
531
532			/*
533			* @public function getSimpleString
534			* @param $string
535			*
536			* @return string
537			*/
538			public function getSimpleString($string)
539			{
540			return "{$string}\n";
541			}
542
543			/*
544			* @public function getHeaderFilesComments
545			* @param string $module
546			* @param string $fileName
547			*/
548			/**
549			* @param $module
550			* @param $fileName
551			* @param $noPhpFile
552			*
553			* @return string
554			*/
555			public function getHeaderFilesComments($module, $fileName, $noPhpFile = null)
556			{
557			$name = $module->getVar('mod_name');
558			$dirname = $module->getVar('mod_dirname');
559			$version = $module->getVar('mod_version');
560			$since = $module->getVar('mod_since');
561			$minXoops = $module->getVar('mod_min_xoops');
562			$author = $module->getVar('mod_author');
563			$credits = $module->getVar('mod_credits');
564			$authorMail = $module->getVar('mod_author_mail');
565			$authorWebsiteUrl = $module->getVar('mod_author_website_url');
566			$license = $module->getVar('mod_license');
567			$subversion = $module->getVar('mod_subversion');
568			$date = date('D Y-m-d H:i:s');
569			if (is_null($noPhpFile)) {
570			$ret = "<?php\n";
571			$ret .= "/*\n";
572			} elseif (is_string($noPhpFile)) {
573			$ret = $noPhpFile;
574			$ret .= "/*\n";
575			} else {
576			$ret .= "/*\n";
			0 ignored issues – show Bug introduced 2016-02-11 00:03 UTC by Report Bug Copy Issue Report The variable `$ret` seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition? This error can happen if you refactor code and forget to move the variable initialization. Let’s take a look at a simple example: function someFunction() { $x = 5; echo $x; } The above code is perfectly fine. Now imagine that we re-order the statements: function someFunction() { echo $x; $x = 5; } In that case, `$x` would be read before it is initialized. This was a very basic example, however the principle is the same for the found issue. Loading history...
577			}
578			$filename = TDMC_CLASSES_PATH.'/files/docs/license.txt';
579			$handle = fopen($filename, 'rb');
580			$data = fread($handle, filesize($filename));
581			fclose($handle);
582			$ret .= $data."\n";
583			$ret .= "*/\n";
584			$copyright = array($name => 'module for xoops', '' => '', '@copyright ' => ' module for xoops', '@license ' => " {$license}", '@package ' => " {$dirname}",
585			'@since ' => " {$since}", '@min_xoops ' => " {$minXoops}", '@author ' => " {$author} - Email:<{$authorMail}> - Website:<{$authorWebsiteUrl}>",
586			'@version ' => " \$Id: {$version} {$fileName} {$subversion} {$date}Z {$credits} \$", );
587			$ret .= TDMCreatePhpCode::getInstance()->getPhpCodeCommentMultiLine($copyright);
588
589			return $ret;
590			}
591
592			/*
593			* @public function renderFile
594			* @param null
595			*/
596			/**
597			* @return string
598			*/
599			public function renderFile()
600			{
601			$fileName = $this->getFileName();
602			$path = $this->getUploadPath().'/'.$fileName;
603			$created = $this->getCreated();
604			$notCreated = $this->getNotCreated();
605			$folderName = $this->getFolderName();
606			$mode = $this->getMode();
607			$ret = '';
608			if (!$this->xoopsFile->__construct($path, true)) {
			0 ignored issues – show Bug introduced 2015-12-23 22:08 UTC by Report Bug Copy Issue Report The method `__construct` cannot be called on `$this->xoopsFile` (of type `string`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
609			// Force to create file if not exist
610			if ($this->xoopsFile->open($mode, true)) {
			0 ignored issues – show Bug introduced 2015-12-23 22:08 UTC by Report Bug Copy Issue Report The method `open` cannot be called on `$this->xoopsFile` (of type `string`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
611			if ($this->xoopsFile->writable()) {
			0 ignored issues – show Bug introduced 2015-12-23 22:08 UTC by Report Bug Copy Issue Report The method `writable` cannot be called on `$this->xoopsFile` (of type `string`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
612			// Integration of the content in the file
613			if (!$this->xoopsFile->write($this->getContent(), $mode, true)) {
			0 ignored issues – show Bug introduced 2015-12-23 22:08 UTC by Report Bug Copy Issue Report The method `write` cannot be called on `$this->xoopsFile` (of type `string`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
614			$ret .= sprintf($notCreated, $fileName, $folderName);
615			$GLOBALS['xoopsTpl']->assign('created', false);
616			exit();
617			}
618			// Created
619			$ret .= sprintf($created, $fileName, $folderName);
620			$GLOBALS['xoopsTpl']->assign('created', true);
621			$this->xoopsFile->close();
			0 ignored issues – show Bug introduced 2015-12-23 22:08 UTC by Report Bug Copy Issue Report The method `close` cannot be called on `$this->xoopsFile` (of type `string`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
622			} else {
623			$ret .= sprintf($notCreated, $fileName, $folderName);
624			$GLOBALS['xoopsTpl']->assign('created', false);
625			}
626			} else {
627			$ret .= sprintf($notCreated, $fileName, $folderName);
628			$GLOBALS['xoopsTpl']->assign('created', false);
629			}
630			}
631
632			return $ret;
633			}
634			}
635

txmodxoops / tdmcreate

Branch — master (31be8b)

TDMCreateFile C

Complexity

Size/Duplication

Coupling/Cohesion

33 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like