Xmf\Module\Helper\AbstractHelper

Complexity

Total Complexity

15

Size/Duplication

Total Lines	105
Duplicated Lines	0 %

Test Coverage

Coverage

62.5%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	setDebug()	0	3	1
A	addLog()	0	8	4
B	__construct()	0	26	6
A	serializeForHelperLog()	0	9	4

<?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.
 */

namespace Xmf\Module\Helper;

/**
 * Xmf\Module\Helper\AbstractHelper defines the basis for various
 * helpers that simplify routine module tasks.
 *
 * @category  Xmf\Module\Helper\AbstractHelper
 * @package   Xmf
 * @author    trabis <lusopoemas@gmail.com>
 * @author    Richard Griffith <richard@geekwright.com>
 * @copyright 2011-2018 XOOPS Project (http://xoops.org)
 * @license   GNU GPL 2 or later (http://www.gnu.org/licenses/gpl-2.0.html)
 * @link      http://xoops.org
 */
abstract class AbstractHelper
{
    /**
     * @var XoopsModule

The type Xmf\Module\Helper\XoopsModule was not found. Did you mean XoopsModule? If so, make sure to prefix the type with \.

     */
    protected $module;

    /**
     * @var bool true if debug is enabled
     */
    protected $debug;

    /**
     * Instantiate a XoopsModule object for the helper to use.
     * The module is determined as follows:
     * - if null is passed, use the current module
     * - if a string is passed, use as dirname to load
     *
     * @param string|null $dirname dirname
     */
    public function __construct($dirname = null)
    {
        $this->module = null;

        if (class_exists('Xoops', false)) {
            $xoops = \Xoops::getInstance();
        }
        if (empty($dirname)) {
            // nothing specified, use current module
            if (isset($xoops)) {
                $this->module = $xoops->module;
            } else {
                $this->module = $GLOBALS['xoopsModule'];
            }
        } else {
            // assume dirname specified, try to get a module object
            if (isset($xoops)) {
                $moduleHandler = $xoops->getHandlerModule();
            } else {
                /* @var $moduleHandler \XoopsModuleHandler */
                $moduleHandler = xoops_getHandler('module');

The function xoops_getHandler() has been deprecated.

            }
            $this->module = $moduleHandler->getByDirname($dirname);
        }
        if (is_object($this->module)) {
            $this->init();
        }
    }

    /**
     * init() is called once/if __construct has a module object.
     * $this->module will have a module object that any further
     * initialization can use.
     *
     * @return void
     */
    abstract public function init();

    /**
     * Set debug option on or off
     *
     * @param bool $bool true to turn on debug logging, false for off
     *
     * @return void
     */
    public function setDebug($bool = true)
    {
        $this->debug = (bool) $bool;
    }

    /**
     * Add a message to the module log
     *
     * @param mixed $log log item, can be message or variable
     *
     * @return void
     */
    public function addLog($log)
    {
        if ($this->debug) {
            $message = $this->serializeForHelperLog($log);
            if (class_exists('Xoops', false)) {
                \Xoops::getInstance()->logger()->debug($message, array('channel'=>'Extra'));
            } elseif (is_object($GLOBALS['xoopsLogger'])) {
                $GLOBALS['xoopsLogger']->addExtra(get_called_class(), $message);
            }
        }
    }

    /**
     * Serialize an arbitrary value to string. Intended for data being addLog()ed
     *
     * @param mixed $value
     *
     * @return string
     */
    protected function serializeForHelperLog($value)
    {
        if (is_resource($value) || !is_null(@get_resource_type($value))) {

The condition is_resource($value) || ! is_null(@get_resource_type($value)) can never be false.

            $value = '(resource)';
        }
        if (!is_string($value)) {

The condition ! is_string($value) can never be true.

            $value = json_encode($value);
        }
        return (string) $value;
    }
}