Config_File::__construct() - Code Metrics - Inspection of "PHP7" - XOOPS/XoopsCore25 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#53)

by Michael

created 2016-03-25 07:29 UTC

Config_File::__construct() A

↳ Parent: Config_File

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	5
rs	9.4285
cc	2
eloc	3
nc	2
nop	1

<?php

/**
 * Config_File class.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * For questions, help, comments, discussion, etc., please join the
 * Smarty mailing list. Send a blank e-mail to
 * [email protected] 
 *
 * @link http://www.smarty.net/
 * @version 2.6.25-dev
 * @copyright Copyright: 2001-2005 New Digital Group, Inc.
 * @author Andrei Zmievski <[email protected]>
 * @access public
 * @package Smarty
 */

/* $Id$ */

/**
 * Config file reading class
 * @package Smarty
 */
class Config_File {
    /**#@+
     * Options
     * @var boolean
     */
    /**
     * Controls whether variables with the same name overwrite each other.
     */
    var $overwrite        =    true;

    /**
     * Controls whether config values of on/true/yes and off/false/no get
     * converted to boolean values automatically.
     */
    var $booleanize        =    true;

    /**
     * Controls whether hidden config sections/vars are read from the file.
     */
    var $read_hidden     =    true;

    /**
     * Controls whether or not to fix mac or dos formatted newlines.
     * If set to true, \r or \r\n will be changed to \n.
     */
    var $fix_newlines =    true;
    /**#@-*/

    /** @access private */
    var $_config_path    = "";
    var $_config_data    = array();
    /**#@-*/

    /**
     * Constructs a new config file class.
     *
     * @param string $config_path (optional) path to the config files
     */
    function __construct($config_path = NULL)

    {
        if (isset($config_path))
            $this->set_path($config_path);
    }


    /**
     * Set the path where configuration files can be found.
     *
     * @param string $config_path path to the config files
     */
    function set_path($config_path)

    {
        if (!empty($config_path)) {
            if (!is_string($config_path) || !file_exists($config_path) || !is_dir($config_path)) {
                $this->_trigger_error_msg("Bad config file path '$config_path'");
                return;
            }
            if(substr($config_path, -1) != DIRECTORY_SEPARATOR) {
                $config_path .= DIRECTORY_SEPARATOR;
            }

            $this->_config_path = $config_path;
        }
    }


    /**
     * Retrieves config info based on the file, section, and variable name.
     *
     * @param string $file_name config file to get info for
     * @param string $section_name (optional) section to get info for
     * @param string $var_name (optional) variable to get info for
     * @return string|array a value or array of values
     */
    function get($file_name, $section_name = NULL, $var_name = NULL)

    {
        if (empty($file_name)) {
            $this->_trigger_error_msg('Empty config file name');
            return;
        } else {
            $file_name = $this->_config_path . $file_name;
            if (!isset($this->_config_data[$file_name]))
                $this->load_file($file_name, false);
        }

        if (!empty($var_name)) {
            if (empty($section_name)) {
                return $this->_config_data[$file_name]["vars"][$var_name];
            } else {
                if(isset($this->_config_data[$file_name]["sections"][$section_name]["vars"][$var_name]))
                    return $this->_config_data[$file_name]["sections"][$section_name]["vars"][$var_name];
                else
                    return array();
            }
        } else {
            if (empty($section_name)) {
                return (array)$this->_config_data[$file_name]["vars"];
            } else {
                if(isset($this->_config_data[$file_name]["sections"][$section_name]["vars"]))
                    return (array)$this->_config_data[$file_name]["sections"][$section_name]["vars"];
                else
                    return array();
            }
        }
    }


    /**
     * Retrieves config info based on the key.
     *
     * @param $file_name string config key (filename/section/var)
     * @return string|array same as get()
     * @uses get() retrieves information from config file and returns it
     */
    function &get_key($config_key)
    {
        list($file_name, $section_name, $var_name) = explode('/', $config_key, 3);
        $result = &$this->get($file_name, $section_name, $var_name);
        return $result;
    }

    /**
     * Get all loaded config file names.
     *
     * @return array an array of loaded config file names
     */
    function get_file_names()

    {
        return array_keys($this->_config_data);
    }


    /**
     * Get all section names from a loaded file.
     *
     * @param string $file_name config file to get section names from
     * @return array an array of section names from the specified file

     */
    function get_section_names($file_name)

    {
        $file_name = $this->_config_path . $file_name;
        if (!isset($this->_config_data[$file_name])) {
            $this->_trigger_error_msg("Unknown config file '$file_name'");
            return;
        }

        return array_keys($this->_config_data[$file_name]["sections"]);
    }


    /**
     * Get all global or section variable names.
     *
     * @param string $file_name config file to get info for
     * @param string $section_name (optional) section to get info for
/**
 * @param array $germany
 * @param array $ireland
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return array an array of variables names from the specified file/section

     */
    function get_var_names($file_name, $section = NULL)

    {
        if (empty($file_name)) {
            $this->_trigger_error_msg('Empty config file name');
            return;
        } else if (!isset($this->_config_data[$file_name])) {
            $this->_trigger_error_msg("Unknown config file '$file_name'");
            return;
        }

        if (empty($section))
            return array_keys($this->_config_data[$file_name]["vars"]);
        else
            return array_keys($this->_config_data[$file_name]["sections"][$section]["vars"]);
    }


    /**
     * Clear loaded config data for a certain file or all files.
     *
     * @param string $file_name file to clear config data for
     */
    function clear($file_name = NULL)

    {
        if ($file_name === NULL)
            $this->_config_data = array();
        else if (isset($this->_config_data[$file_name]))
            $this->_config_data[$file_name] = array();
    }


    /**
     * Load a configuration file manually.
     *
     * @param string $file_name file name to load
     * @param boolean $prepend_path whether current config path should be
     *                              prepended to the filename
     */
    function load_file($file_name, $prepend_path = true)

    {
        if ($prepend_path && $this->_config_path != "")
            $config_file = $this->_config_path . $file_name;
        else
            $config_file = $file_name;

        ini_set('track_errors', true);
        $fp = @fopen($config_file, "r");
        if (!is_resource($fp)) {
            $this->_trigger_error_msg("Could not open config file '$config_file'");
            return false;
        }

        $contents = ($size = filesize($config_file)) ? fread($fp, $size) : '';
        fclose($fp);

        $this->_config_data[$config_file] = $this->parse_contents($contents);
        return true;
    }

    /**
     * Store the contents of a file manually.
     *
     * @param string $config_file file name of the related contents
     * @param string $contents the file-contents to parse
     */
    function set_file_contents($config_file, $contents)

    {
        $this->_config_data[$config_file] = $this->parse_contents($contents);
        return true;
    }

    /**
     * parse the source of a configuration file manually.
     *
     * @param string $contents the file-contents to parse
     */
    function parse_contents($contents)

    {
        if($this->fix_newlines) {
            // fix mac/dos formatted newlines
            $contents = preg_replace('!\r\n?!', "\n", $contents);
        }

        $config_data = array();
        $config_data['sections'] = array();
        $config_data['vars'] = array();

        /* reference to fill with data */
        $vars =& $config_data['vars'];

        /* parse file line by line */
        preg_match_all('!^.*\r?\n?!m', $contents, $match);
        $lines = $match[0];
        for ($i=0, $count=count($lines); $i<$count; $i++) {
            $line = $lines[$i];
            if (empty($line)) continue;

            if ( substr($line, 0, 1) == '[' && preg_match('!^\[(.*?)\]!', $line, $match) ) {
                /* section found */
                if (substr($match[1], 0, 1) == '.') {
                    /* hidden section */
                    if ($this->read_hidden) {
                        $section_name = substr($match[1], 1);
                    } else {
                        /* break reference to $vars to ignore hidden section */
                        unset($vars);
                        $vars = array();
                        continue;
                    }
                } else {                    
                    $section_name = $match[1];
                }
                if (!isset($config_data['sections'][$section_name]))
                    $config_data['sections'][$section_name] = array('vars' => array());
                $vars =& $config_data['sections'][$section_name]['vars'];
                continue;
            }

            if (preg_match('/^\s*(\.?\w+)\s*=\s*(.*)/s', $line, $match)) {
                /* variable found */
                $var_name = rtrim($match[1]);
                if (strpos($match[2], '"""') === 0) {
                    /* handle multiline-value */
                    $lines[$i] = substr($match[2], 3);
                    $var_value = '';
                    while ($i<$count) {
                        if (($pos = strpos($lines[$i], '"""')) === false) {
                            $var_value .= $lines[$i++];
                        } else {
                            /* end of multiline-value */
                            $var_value .= substr($lines[$i], 0, $pos);
                            break;
                        }
                    }
                    $booleanize = false;

                } else {
                    /* handle simple value */
                    $var_value = preg_replace('/^([\'"])(.*)\1$/', '\2', rtrim($match[2]));
                    $booleanize = $this->booleanize;

                }
                $this->_set_config_var($vars, $var_name, $var_value, $booleanize);
            }
            /* else unparsable line / means it is a comment / means ignore it */
        }
        return $config_data;
    }

    /**#@+ @access private */
    /**
     * @param array &$container
     * @param string $var_name
     * @param mixed $var_value
     * @param boolean $booleanize determines whether $var_value is converted to
     *                            to true/false
     */
    function _set_config_var(&$container, $var_name, $var_value, $booleanize)

    {
        if (substr($var_name, 0, 1) == '.') {
            if (!$this->read_hidden)
                return;
            else
                $var_name = substr($var_name, 1);
        }

        if (!preg_match("/^[a-zA-Z_]\w*$/", $var_name)) {
            $this->_trigger_error_msg("Bad variable name '$var_name'");
            return;
        }

        if ($booleanize) {
            if (preg_match("/^(on|true|yes)$/i", $var_value))
                $var_value = true;
            else if (preg_match("/^(off|false|no)$/i", $var_value))
                $var_value = false;
        }

        if (!isset($container[$var_name]) || $this->overwrite)
            $container[$var_name] = $var_value;
        else {
            settype($container[$var_name], 'array');
            $container[$var_name][] = $var_value;
        }
    }

    /**
     * @uses trigger_error() creates a PHP warning/error
     * @param string $error_msg
     * @param integer $error_type one of
     */
    function _trigger_error_msg($error_msg, $error_type = E_USER_WARNING)

    {
        trigger_error("Config_File error: $error_msg", $error_type);
    }
    /**#@-*/
}

?>



1		<?php
2
3		/**
4		* Config_File class.
5		*
6		* This library is free software; you can redistribute it and/or
7		* modify it under the terms of the GNU Lesser General Public
8		* License as published by the Free Software Foundation; either
9		* version 2.1 of the License, or (at your option) any later version.
10		*
11		* This library is distributed in the hope that it will be useful,
12		* but WITHOUT ANY WARRANTY; without even the implied warranty of
13		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14		* Lesser General Public License for more details.
15		*
16		* You should have received a copy of the GNU Lesser General Public
17		* License along with this library; if not, write to the Free Software
18		* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19		*
20		* For questions, help, comments, discussion, etc., please join the
21		* Smarty mailing list. Send a blank e-mail to
22		* [email protected]
23		*
24		* @link http://www.smarty.net/
25		* @version 2.6.25-dev
26		* @copyright Copyright: 2001-2005 New Digital Group, Inc.
27		* @author Andrei Zmievski <[email protected]>
28		* @access public
29		* @package Smarty
30		*/
31
32		/* $Id$ */
33
34		/**
35		* Config file reading class
36		* @package Smarty
37		*/
38		class Config_File {
39		/**#@+
40		* Options
41		* @var boolean
42		*/
43		/**
44		* Controls whether variables with the same name overwrite each other.
45		*/
46		var $overwrite = true;
47
48		/**
49		* Controls whether config values of on/true/yes and off/false/no get
50		* converted to boolean values automatically.
51		*/
52		var $booleanize = true;
53
54		/**
55		* Controls whether hidden config sections/vars are read from the file.
56		*/
57		var $read_hidden = true;
58
59		/**
60		* Controls whether or not to fix mac or dos formatted newlines.
61		* If set to true, \r or \r\n will be changed to \n.
62		*/
63		var $fix_newlines = true;
64		/*#@-/
65
66		/** @access private */
67		var $_config_path = "";
68		var $_config_data = array();
69		/*#@-/
70
71		/**
72		* Constructs a new config file class.
73		*
74		* @param string $config_path (optional) path to the config files
75		*/
76		function __construct($config_path = NULL)
		0 ignored issues – show Best Practice introduced 2016-03-07 05:16 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
77		{
78		if (isset($config_path))
79		$this->set_path($config_path);
80		}
81
82
83		/**
84		* Set the path where configuration files can be found.
85		*
86		* @param string $config_path path to the config files
87		*/
88		function set_path($config_path)
		0 ignored issues – show Best Practice introduced 2016-03-07 05:16 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
89		{
90		if (!empty($config_path)) {
91		if (!is_string($config_path) \|\| !file_exists($config_path) \|\| !is_dir($config_path)) {
92		$this->_trigger_error_msg("Bad config file path '$config_path'");
93		return;
94		}
95		if(substr($config_path, -1) != DIRECTORY_SEPARATOR) {
96		$config_path .= DIRECTORY_SEPARATOR;
97		}
98
99		$this->_config_path = $config_path;
100		}
101		}
102
103
104		/**
105		* Retrieves config info based on the file, section, and variable name.
106		*
107		* @param string $file_name config file to get info for
108		* @param string $section_name (optional) section to get info for
109		* @param string $var_name (optional) variable to get info for
110		* @return string\|array a value or array of values
111		*/
112		function get($file_name, $section_name = NULL, $var_name = NULL)
		0 ignored issues – show Best Practice introduced 2016-03-07 05:16 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
113		{
114		if (empty($file_name)) {
115		$this->_trigger_error_msg('Empty config file name');
116		return;
117		} else {
118		$file_name = $this->_config_path . $file_name;
119		if (!isset($this->_config_data[$file_name]))
120		$this->load_file($file_name, false);
121		}
122
123		if (!empty($var_name)) {
124		if (empty($section_name)) {
125		return $this->_config_data[$file_name]["vars"][$var_name];
126	View Code Duplication	} else {
127		if(isset($this->_config_data[$file_name]["sections"][$section_name]["vars"][$var_name]))
128		return $this->_config_data[$file_name]["sections"][$section_name]["vars"][$var_name];
129		else
130		return array();
131		}
132		} else {
133		if (empty($section_name)) {
134		return (array)$this->_config_data[$file_name]["vars"];
135	View Code Duplication	} else {
136		if(isset($this->_config_data[$file_name]["sections"][$section_name]["vars"]))
137		return (array)$this->_config_data[$file_name]["sections"][$section_name]["vars"];
138		else
139		return array();
140		}
141		}
142		}
143
144
145		/**
146		* Retrieves config info based on the key.
147		*
148		* @param $file_name string config key (filename/section/var)
149		* @return string\|array same as get()
150		* @uses get() retrieves information from config file and returns it
151		*/
152		function &get_key($config_key)
153		{
154		list($file_name, $section_name, $var_name) = explode('/', $config_key, 3);
155		$result = &$this->get($file_name, $section_name, $var_name);
156		return $result;
157		}
158
159		/**
160		* Get all loaded config file names.
161		*
162		* @return array an array of loaded config file names
163		*/
164		function get_file_names()
		0 ignored issues – show Best Practice introduced 2016-03-07 05:16 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
165		{
166		return array_keys($this->_config_data);
167		}
168
169
170		/**
171		* Get all section names from a loaded file.
172		*
173		* @param string $file_name config file to get section names from
174		* @return array an array of section names from the specified file
		0 ignored issues – show Documentation introduced 2016-03-07 05:16 UTC by Report Bug Copy Issue Report Should the return type not be `null\|array`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
175		*/
176		function get_section_names($file_name)
		0 ignored issues – show Best Practice introduced 2016-03-07 05:16 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
177		{
178		$file_name = $this->_config_path . $file_name;
179		if (!isset($this->_config_data[$file_name])) {
180		$this->_trigger_error_msg("Unknown config file '$file_name'");
181		return;
182		}
183
184		return array_keys($this->_config_data[$file_name]["sections"]);
185		}
186
187
188		/**
189		* Get all global or section variable names.
190		*
191		* @param string $file_name config file to get info for
192		* @param string $section_name (optional) section to get info for
		0 ignored issues – show Documentation introduced 2016-03-07 05:16 UTC by Report Bug Copy Issue Report There is no parameter named `$section_name`. Did you maybe mean `$section`? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. It has, however, found a similar but not annotated parameter which might be a good fit. Consider the following example. The parameter `$ireland` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $ireland */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was changed, but the annotation was not. Loading history...
193		* @return array an array of variables names from the specified file/section
		0 ignored issues – show Documentation introduced 2016-03-07 05:16 UTC by Report Bug Copy Issue Report Should the return type not be `null\|array`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
194		*/
195		function get_var_names($file_name, $section = NULL)
		0 ignored issues – show Best Practice introduced 2016-03-07 05:16 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
196		{
197		if (empty($file_name)) {
198		$this->_trigger_error_msg('Empty config file name');
199		return;
200		} else if (!isset($this->_config_data[$file_name])) {
201		$this->_trigger_error_msg("Unknown config file '$file_name'");
202		return;
203		}
204
205		if (empty($section))
206		return array_keys($this->_config_data[$file_name]["vars"]);
207		else
208		return array_keys($this->_config_data[$file_name]["sections"][$section]["vars"]);
209		}
210
211
212		/**
213		* Clear loaded config data for a certain file or all files.
214		*
215		* @param string $file_name file to clear config data for
216		*/
217		function clear($file_name = NULL)
		0 ignored issues – show Best Practice introduced 2016-03-07 05:16 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
218		{
219		if ($file_name === NULL)
220		$this->_config_data = array();
221		else if (isset($this->_config_data[$file_name]))
222		$this->_config_data[$file_name] = array();
223		}
224
225
226		/**
227		* Load a configuration file manually.
228		*
229		* @param string $file_name file name to load
230		* @param boolean $prepend_path whether current config path should be
231		* prepended to the filename
232		*/
233		function load_file($file_name, $prepend_path = true)
		0 ignored issues – show Best Practice introduced 2016-03-07 05:16 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
234		{
235		if ($prepend_path && $this->_config_path != "")
236		$config_file = $this->_config_path . $file_name;
237		else
238		$config_file = $file_name;
239
240		ini_set('track_errors', true);
241		$fp = @fopen($config_file, "r");
242		if (!is_resource($fp)) {
243		$this->_trigger_error_msg("Could not open config file '$config_file'");
244		return false;
245		}
246
247		$contents = ($size = filesize($config_file)) ? fread($fp, $size) : '';
248		fclose($fp);
249
250		$this->_config_data[$config_file] = $this->parse_contents($contents);
251		return true;
252		}
253
254		/**
255		* Store the contents of a file manually.
256		*
257		* @param string $config_file file name of the related contents
258		* @param string $contents the file-contents to parse
259		*/
260		function set_file_contents($config_file, $contents)
		0 ignored issues – show Best Practice introduced 2016-03-07 05:16 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
261		{
262		$this->_config_data[$config_file] = $this->parse_contents($contents);
263		return true;
264		}
265
266		/**
267		* parse the source of a configuration file manually.
268		*
269		* @param string $contents the file-contents to parse
270		*/
271		function parse_contents($contents)
		0 ignored issues – show Best Practice introduced 2016-03-07 05:16 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
272		{
273		if($this->fix_newlines) {
274		// fix mac/dos formatted newlines
275		$contents = preg_replace('!\r\n?!', "\n", $contents);
276		}
277
278		$config_data = array();
279		$config_data['sections'] = array();
280		$config_data['vars'] = array();
281
282		/* reference to fill with data */
283		$vars =& $config_data['vars'];
284
285		/* parse file line by line */
286		preg_match_all('!^.*\r?\n?!m', $contents, $match);
287		$lines = $match[0];
288		for ($i=0, $count=count($lines); $i<$count; $i++) {
289		$line = $lines[$i];
290		if (empty($line)) continue;
291
292		if ( substr($line, 0, 1) == '[' && preg_match('!^\[(.*?)\]!', $line, $match) ) {
293		/* section found */
294		if (substr($match[1], 0, 1) == '.') {
295		/* hidden section */
296		if ($this->read_hidden) {
297		$section_name = substr($match[1], 1);
298		} else {
299		/* break reference to $vars to ignore hidden section */
300		unset($vars);
301		$vars = array();
302		continue;
303		}
304		} else {
305		$section_name = $match[1];
306		}
307		if (!isset($config_data['sections'][$section_name]))
308		$config_data['sections'][$section_name] = array('vars' => array());
309		$vars =& $config_data['sections'][$section_name]['vars'];
310		continue;
311		}
312
313		if (preg_match('/^\s(\.?\w+)\s=\s(.)/s', $line, $match)) {
314		/* variable found */
315		$var_name = rtrim($match[1]);
316		if (strpos($match[2], '"""') === 0) {
317		/* handle multiline-value */
318		$lines[$i] = substr($match[2], 3);
319		$var_value = '';
320		while ($i<$count) {
321		if (($pos = strpos($lines[$i], '"""')) === false) {
322		$var_value .= $lines[$i++];
323		} else {
324		/* end of multiline-value */
325		$var_value .= substr($lines[$i], 0, $pos);
326		break;
327		}
328		}
329		$booleanize = false;
330
331		} else {
332		/* handle simple value */
333		$var_value = preg_replace('/^([\'"])(.*)\1$/', '\2', rtrim($match[2]));
334		$booleanize = $this->booleanize;
335
336		}
337		$this->_set_config_var($vars, $var_name, $var_value, $booleanize);
338		}
339		/* else unparsable line / means it is a comment / means ignore it */
340		}
341		return $config_data;
342		}
343
344		/*#@+ @access private /
345		/**
346		* @param array &$container
347		* @param string $var_name
348		* @param mixed $var_value
349		* @param boolean $booleanize determines whether $var_value is converted to
350		* to true/false
351		*/
352		function _set_config_var(&$container, $var_name, $var_value, $booleanize)
		0 ignored issues – show Best Practice introduced 2016-03-07 05:16 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
353		{
354		if (substr($var_name, 0, 1) == '.') {
355		if (!$this->read_hidden)
356		return;
357		else
358		$var_name = substr($var_name, 1);
359		}
360
361		if (!preg_match("/^[a-zA-Z_]\w*$/", $var_name)) {
362		$this->_trigger_error_msg("Bad variable name '$var_name'");
363		return;
364		}
365
366		if ($booleanize) {
367		if (preg_match("/^(on\|true\|yes)$/i", $var_value))
368		$var_value = true;
369		else if (preg_match("/^(off\|false\|no)$/i", $var_value))
370		$var_value = false;
371		}
372
373		if (!isset($container[$var_name]) \|\| $this->overwrite)
374		$container[$var_name] = $var_value;
375		else {
376		settype($container[$var_name], 'array');
377		$container[$var_name][] = $var_value;
378		}
379		}
380
381		/**
382		* @uses trigger_error() creates a PHP warning/error
383		* @param string $error_msg
384		* @param integer $error_type one of
385		*/
386		function _trigger_error_msg($error_msg, $error_type = E_USER_WARNING)
		0 ignored issues – show Best Practice introduced 2016-03-07 05:16 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
387		{
388		trigger_error("Config_File error: $error_msg", $error_type);
389		}
390		/*#@-/
391		}
392
393		?>
		0 ignored issues – show Best Practice introduced 2016-03-07 05:16 UTC by Report Bug Copy Issue Report It is not recommended to use PHP's closing tag `?>` in files other than templates. Using a closing tag in PHP files that only contain PHP code is not recommended as you might accidentally add whitespace after the closing tag which would then be output by PHP. This can cause severe problems, for example headers cannot be sent anymore. A simple precaution is to leave off the closing tag as it is not required, and it also has no negative effects whatsoever. Loading history...
394

XOOPS / XoopsCore25

Pull Request — master (#53)

Config_File::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like