JavaScript::pluck() - Code Metrics - blok/laravel-javascript - Measure and Improve Code Quality continuously with Scrutinizer

JavaScript::pluck() A
last analyzed 2020-02-12 08:36 UTC

↳ Parent: JavaScript
Complexity

Conditions	1
Paths	1
Size

Total Lines	6
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	3
c	1
b	0
f	0
nc	1
nop	2
dl	0
loc	6
rs	10
<?php namespace Blok\JavaScript;

use Illuminate\Support\Arr;

/**
 * Class JavaScript
 *
 * @package Blok\JavaScript
 *
 * @see https://github.com/cretueusebiu/laravel-javascript
 * @see https://github.com/laracasts/PHP-Vars-To-Js-Transformer
 */
class JavaScript
{
    /**
     * @var string
     */
    private static $globalNamespace = 'JavaScript';

    /**
     * Globals namespace
     * @var string
     */
    private $namespace = '__app';

    private static $_instances = [];

    /**
     * Selected data
     * @var null
     */
    private $activeData = null;

    /**
     * JavaScript constructor.
     * @param null $namespace

     *
     * @example
     * $js = new JavaScript('__globals');
     * $js->set('foo', 'bar');
     */
    public function __construct($namespace = null)
    {
        if (!is_string($namespace)) {

            $namespace = null;
        }

        if ($namespace) {

            $this->namespace = $namespace;
        }

        if (!isset($GLOBALS[static::$globalNamespace])) {

            $GLOBALS[static::$globalNamespace] = [];
        }

        if (!isset($GLOBALS[static::$globalNamespace][$this->namespace])) {
            $GLOBALS[static::$globalNamespace][$this->namespace] = [];
        }

        self::$_instances[$this->namespace] = $this;
    }

    /**
     * Calling methods statically
     * @param $name
     * @param $arguments
     * @return mixed
     * @throws \Exception
     */
    public static function __callStatic($name, $arguments)
    {
        $instance = new self();

        if (method_exists($instance, $name)) {
            return call_user_func_array([$instance, $name], $arguments);
        }

        throw new \Exception('[' . static::class . '::' . $name . '] method is not implemented');
    }

    /**
     * Magic getter
     * @param $name
     * @return mixed
     */
    public function __get($name)
    {
        return $this->get($name);
    }

    /**
     * Magic setter
     * @param $name
     * @param $value
     * @return JavaScript
     */
    public function __set($name, $value)
    {
        return $this->set($name, $value);
    }

    /**
     * Remove one or many array items from a given array using "dot" notation.
     * @param array|string $keys
     * @return $this
     */
    public function forget($keys)
    {
        $data = $this->getActiveData();
        $this->setActiveData(Arr::forget($data, $keys), false);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {

        return $this;
    }

    /**
     * Check if an item or items exist in an array using "dot" notation.
     *
     * @param  string|array $keys
     * @return bool
     */
    public function has($keys)
    {
        return Arr::has($GLOBALS[static::$globalNamespace][$this->namespace], $keys);

    }

    /**
     * Get an item from an array using "dot" notation.
     *
     * @param  string $key
     * @param  mixed $default
     * @return mixed
     */
    public function get($key = null, $default = null)
    {
        $data = $this->getActiveData();

        if (is_null($key)) {
            return $data;
        }

        return Arr::get($data, $key, $default);
    }

    /**
     * Set an array item to a given value using "dot" notation.
     *
     * @param  string $key
     * @param  mixed $value
     * @return $this
     */
    public function set($key, $value = null)
    {
        if (is_null($value)) {
            $key = Arr::wrap($key);

            $this->merge($key);

            return $this;
        } elseif (isset($GLOBALS[static::$globalNamespace][$this->namespace][$key]) && is_array($value)) {

            foreach ($value as $item) {
                if (!in_array($item, $GLOBALS[static::$globalNamespace][$this->namespace][$key])) {
                    $GLOBALS[static::$globalNamespace][$this->namespace][$key][] = $item;
                }
            }
        } else {
            Arr::set($GLOBALS[static::$globalNamespace][$this->namespace], $key, $value);
        }

        return $this;
    }

    /**
     * @alias Javascript::set()
     * @param $key
     * @param $value
     * @return JavaScript
     */
    public function add($key, $value = null){
        return $this->set($key, $value);
    }

    /**
     * Set the namespace
     * @param $namespace
     * @return $this
     */
    public static function namespace($namespace)
    {
        if (!isset(self::$_instances[$namespace])) {
            self::$_instances[$namespace] = new static($namespace);
        }

        return self::$_instances[$namespace];
    }

    /**
     * Flatten a multi-dimensional associative array with dots.
     *
     * @param  string $prepend
     * @return $this
     */
    public function dot($prepend = '')
    {
        $data = $this->getActiveData();
        $this->setActiveData(Arr::dot($data, $prepend));

        return $this;
    }

    /**
     * Get a subset of the items from the given array.
     *
     * @param  array|string $keys
     * @return $this
     */
    public function only($keys)
    {
        $data = $this->getActiveData();
        $this->setActiveData(Arr::only($data, $keys));

        return $this;
    }

    /**
     * Pluck an array of values from an array.
     *
     * @param  string|array|null $value
     * @param null $key

     * @return $this
     */
    public function pluck($value, $key = null)
    {
        $data = $this->getActiveData();
        $this->setActiveData(Arr::pluck($data, $value, $key));

        return $this;
    }

    /**
     * Filter the array using the given callback.
     *
     * @param  callable $callback
     * @return $this
     */
    public function where(callable $callback)
    {
        $data = $this->getActiveData();
        $this->setActiveData(Arr::where($data, $callback));

        return $this;
    }

    /**
     * Merge the given arrays
     *
     * @param  array * $arrays
     * @return $this
     * @throws \Exception
     */
    public function merge()
    {
        $arrays = func_get_args();

        foreach ($arrays as $array) {
            if (!is_array($array)) {
                throw new \Exception('[Hook::merge] all arguments must be Array.');
            }

            foreach ($array as $key => $value) {
                if ($this->has($key)) {
                    $tmp = $this->get($key);

                    if (is_array($tmp)) {
                        $value = Arr::wrap($value);
                        $value = array_merge_recursive($tmp, $value);
                    }
                }

                $this->set($key, $value);
            }
        }

        return $this;
    }

    /**
     * JSON encode
     * @return string
     */
    public function toJson()
    {
        return json_encode($this->get(), true);
        return json_encode($this->get(), /** @scrutinizer ignore-type */ true);
    }

    /**
     * Render as Script tag
     * @param null $varName

     * @param array $variables
     * @param bool $scriptTag
     * @return string
     * @internal param null $namespace
     */
    public function render($varName = null, $variables = [], $scriptTag = true)
    {
        if (is_null($varName)) {

            $varName = $this->namespace;
        }

        $this->merge($variables);

        return ($scriptTag?'<script>':'').'window.' . $varName . ' = ' . $this->toJson() . ';'.($scriptTag?'</script>':'');
    }

    public function renderVar($namespace = null, $variables = []){
        return $this->render($namespace, $variables, false);
    }

    /**
     * Retrieve selected data
     * @return mixed|null
     */
    private function getActiveData()
    {
        if (!is_null($this->activeData)) {
            return $this->activeData;
        }

        return $GLOBALS[static::$globalNamespace][$this->namespace];

    }

    /**
     * Set selected data
     * @param $data
     */
    private function setActiveData($data, $force = true)
    {
        if ($force) {
            $this->activeData = $data;
        } else {
            $GLOBALS[static::$globalNamespace][$this->namespace] = $data;

        }
    }
}
blok / laravel-javascript

JavaScript::pluck() A last analyzed 2020-02-12 08:36 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

JavaScript::pluck() A
last analyzed 2020-02-12 08:36 UTC
