Setting::load() - Code Metrics - joaogl/support - Measure and Improve Code Quality continuously with Scrutinizer

Setting::load() A
last analyzed 2016-05-03 08:07 UTC

↳ Parent: Setting
Complexity

Conditions	4
Paths	8
Size

Total Lines	14
Code Lines	8
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
c	1
b	0
f	0
dl	0
loc	14
rs	9.2
cc	4
eloc	8
nc	8
nop	2
<?php namespace jlourenco\support;

/*
 * This is a Laravel package that is not being used on the
 * vendors folder because it does not support Laravel 5
 */

/*

 * ---------------------------------------------
 * | Do not remove!!!!                         |
 * |                                           |
 * | @package   PhoenixCore                    |
 * | @version   2.0                            |
 * | @develper  Phil F (http://www.Weztec.com) |
 * | @author    Phoenix Development Team       |
 * | @license   Free to all                    |
 * | @copyright 2013 Phoenix Group             |
 * | @link      http://www.phoenix-core.com    |
 * ---------------------------------------------
 *
 * Example syntax:
 * use Setting (If you are using namespaces)
 *
 * Single dimension
 * set:         Setting::set('name', 'Phil'))
 * get:         Setting::get('name')
 * forget:      Setting::forget('name')
 * has:         Setting::has('name')
 *
 * Multi dimensional
 * set:         Setting::set('names' , array('firstName' => 'Phil', 'surname' => 'F'))
 * setArray:    Setting::setArray(array('firstName' => 'Phil', 'surname' => 'F'))
 * get:         Setting::get('names.firstName')
 * forget:      Setting::forget('names.surname'))
 * has:         Setting::has('names.firstName')
 *
 * Clear:
 * clear:        Setting::clear()
 *
 * Using a different path (make sure the path exists and is writable) *
 * Setting::path('setting2.json')->set(array('names2' => array('firstName' => 'Phil', 'surname' => 'F')));
 *
 * Using a different filename
 * Setting::filename('setting2.json')->set(array('names2' => array('firstName' => 'Phil', 'surname' => 'F')));
 *
 * Using both a different path and filename (make sure the path exists and is writable)
 * Setting::path(app_path().'/storage/meta/sub')->filename('dummy.json')->set(array('names2' => array('firstName' => 'Phil', 'surname' => 'F')));
 */

/**
 * Class Setting
 * @package Philf\Setting
 */
class Setting {
    /**
     * The path to the file
     * @var string
     */
    protected $path;
    /**
     * The filename used to store the config
     * @var string
     */
    protected $filename;
    /**
     * The class working array
     * @var array
     */
    protected $settings;
    /**
     * Create the Setting instance
     * @param string $path      The path to the file
     * @param string $filename  The filename
     * @param interfaces\FallbackInterface $fallback
     */
    public function __construct($path, $filename, $fallback = null)
    {
        $this->path     = $path;
        $this->filename = $filename;
        $this->fallback = $fallback;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        // Load the file and store the contents in $this->settings
        $this->load($this->path, $this->filename);
    }
    /**
     * Set the path to the file to use
     * @param  string $path The path to the file
     * @return \Philf\Setting\Setting
     */
    public function path($path)
    {
        $this->path = $path;
        return $this;
    }
    /**
     * Set the filename to use
     * @param  string $filename The filename
     * @return \Philf\Setting\Setting
     */
    public function filename($filename)
    {
        $this->filename = $filename;
        return $this;
    }
    /**
     * Get a value and return it
     * @param string $key String using dot notation
     * @param Mixed $default
     * @return Mixed             The value(s) found
     */
    public function get($key = null, $default = null)
    {
        if (empty($key))
        {
            return $this->settings;
        }
        $ts = microtime(true);
        if($ts !== array_get($this->settings, $key, $ts))
        {
            return array_get($this->settings, $key);
        }
        if ( ! is_null($this->fallback) and $this->fallback->fallbackHas($key))
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
        {
            return $this->fallback->fallbackGet($key, $default);
        }
        return $default;
    }
    /**
     * Store the passed value in to the json file
     * @param $key
     * @param  mixed $value The value(s) to be stored
     * @return void
     */
    public function set($key, $value)
    {
        array_set($this->settings,$key,$value);
        $this->save($this->path, $this->filename);
        $this->load($this->path, $this->filename);
    }
    /**
     * Forget the value(s) currently stored
     * @param  mixed $deleteKey The value(s) to be removed (dot notation)
     * @return void
     */
    public function forget($deleteKey)
    {
        array_forget($this->settings,$deleteKey);
        $this->save($this->path, $this->filename);
        $this->load($this->path, $this->filename);
    }
    /**
     * Check to see if the value exists
     * @param  string  $searchKey The key to search for
     * @return boolean            True: found - False not found
     */
    public function has($searchKey)
    {
        $default = microtime(true);
        if($default == array_get($this->settings, $searchKey, $default) and !is_null($this->fallback))
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
        {
            return $this->fallback->fallbackHas($searchKey);
        }
        return $default !== array_get($this->settings, $searchKey, $default);
    }
    /**
     * Load the file in to $this->settings so values can be used immediately
     * @param  string $path     The path to be used
     * @param  string $filename The filename to be used
     * @return \Philf\Setting\Setting
     */
    public function load($path = null, $filename = null)
    {
        $this->path     = isset($path) ? $path : $this->path;
        $this->filename = isset($filename) ? $filename : $this->filename;
        if (is_file($this->path.'/'.$this->filename))
        {
            $this->settings = json_decode(file_get_contents($this->path.'/'.$this->filename), true);

        }
        else
        {
            $this->settings = array();
        }
        return $this;
    }
    /**
     * Save the file
     * @param  string $path     The path to be used
     * @param  string $filename The filename to be used
     * @return void
     */
    public function save($path = null, $filename = null)
    {
        $this->path     = isset($path) ? $path : $this->path;
        $this->filename = isset($filename) ? $filename : $this->filename;
        if ( ! file_exists($this->path))
        {
            mkdir($this->path, 0755, true);
        }
        $fh = fopen($this->path.'/'.$this->filename, 'w+');
        fwrite($fh, json_encode($this->settings));
        fclose($fh);
    }
    /**
     * Clears the JSON Config file
     */
    public function clear()
    {
        $this->settings = array();
        $this->save($this->path, $this->filename);
        $this->load($this->path, $this->filename);
    }
    /**
     * This will mass assign data to the Setting
     * @param array $data
     */
    public function setArray(array $data)
    {
        foreach ($data as $key => $value)
        {
            array_set($this->settings,$key,$value);
        }
        $this->save($this->path, $this->filename);
        $this->load($this->path, $this->filename);
    }

}
Setting::load() A
last analyzed 2016-05-03 08:07 UTC

Complexity

Size

Duplication

Importance

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

joaogl / support

Setting::load() A last analyzed 2016-05-03 08:07 UTC

Complexity

Size

Duplication

Importance

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Duplication Side-by-Side

Filter issues like

Setting::load() A
last analyzed 2016-05-03 08:07 UTC
