ArraySafe::offsetExists() - Code Metrics - Inspection of "json handler formatting" - php-resta/resta-core - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed
Push — master ( c91700...65feeb )

by Php Easy Api
created 2019-10-15 11:10 UTC
ArraySafe::offsetExists() A

↳ Parent: ArraySafe
Complexity

Conditions	3
Paths	3
Size

Total Lines	11
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	3
eloc	5
nc	3
nop	1
dl	0
loc	11
rs	10
c	1
b	0
f	0
<?php


namespace Resta\Support;

class ArraySafe implements \JsonSerializable, \ArrayAccess {

    /**
     * @var array
     */
    private $data;

    /**
     * SafeArray constructor.
     *
     * @param array $data
     */
    public function __construct( array $data = [] )
    {
        $this->data = $data;
    }

    /**
     * @param array $target
     * @param array $indices
     *
     * @return array|mixed|null
     */
    public function safeGet( array $target, $indices )
    {
        $movingTarget = $target;

        foreach ( $indices as $index )
        {
            $isArray = is_array( $movingTarget ) || $movingTarget instanceof ArrayAccess;

            if ( ! $isArray || ! isset( $movingTarget[ $index ] ) ) return NULL;

            $movingTarget = $movingTarget[ $index ];
        }

        return $movingTarget;
    }

    /**
     * @param array $keys
     *
     * @return array|mixed|null
     */
    public function getKeys( array $keys )
    {
        return static::safeGet( $this->data, $keys );
        return static::/** @scrutinizer ignore-call */ safeGet( $this->data, $keys );
    }

    /**
     * <p>Access nested array index values by providing a dot notation access string.</p>
     * <p>Example: $safeArrayGetter->get('customer.paymentInfo.ccToken') ==
     * $array['customer']['paymentInfo']['ccToken']</p>
     *
     * @param $accessString
     *
     * @return array|mixed|null
     */
    public function get( $accessString )
    {
        return $this->getKeys( $this->parseDotNotation( $accessString ) );
    }

    /**
     * @param      $propString
     * @param      $value
     *
     * @return $this
     */
    public function set( $propString, $value )
    {
        $movingTarget = &$this->data;
        $keys         = $this->parseDotNotation( $propString );
        $length       = count( $keys );

        foreach ( $keys as $i => $key )
        {
            $lastKey = $i === $length - 1;
            $isset   = isset( $movingTarget[ $key ] );

            if ( $isset && ! $lastKey && ! is_array( $movingTarget[ $key ] ) )
            {
                throw new InvalidArgumentException( sprintf(

                    "Attempted to set/access the property %s like an array, but is of type: %s",
                    $key,
                    gettype( $movingTarget[ $key ] )
                ) );
            }

            if ( ! $isset || ! is_array( $movingTarget[ $key ] ) ) $movingTarget[ $key ] = [];

            $movingTarget = &$movingTarget[ $key ];
        }

        $movingTarget = $value;

        return $this;
    }

    /**
     * @param $string
     *
     * @return array
     */
    protected function parseDotNotation( $string )
    {
        return explode( '.', strval( $string ) );
    }

    /**
     * @return array
     */
    public function toArray()
    {
        return $this->data;
    }

    /**
     * @param int $options
     * @param int $depth
     *
     * @return string
     */
    public function toJson( $options = 0, $depth = 512 )
    {
        return json_encode( $this, $options, $depth );
    }

    /**
     * @param array $data
     *
     * @return static
     */
    public static function newFromArray( array $data )
    {
        return new static( $data );
    }

    /**
     * @param \stdClass $data
     *
     * @return static
     */
    public static function newFromStdObject( \stdClass $data )
    {
        return new static( json_decode( json_encode( $data ), TRUE ) );
    }

    /**
     * Specify data which should be serialized to JSON
     * @link http://php.net/manual/en/jsonserializable.jsonserialize.php
     * @return array data which can be serialized by <b>json_encode</b>,
     * which is a value of any type other than a resource.
     * @since 5.4.0
     */
    function jsonSerialize()

    {
        return $this->toArray();
    }

    /**
     * Whether a offset exists
     * @link http://php.net/manual/en/arrayaccess.offsetexists.php
     *
     * @param mixed $offset <p>
     * An offset to check for.
     * </p>
     *
     * @return boolean true on success or false on failure.
     * </p>
     * <p>
     * The return value will be casted to boolean if non-boolean was returned.
     * @since 5.0.0
     */
    public function offsetExists( $offset )
    {
        $movingTarget = $this->data;

        foreach ( $this->parseDotNotation( $offset ) as $i )
        {
            if ( ! isset( $movingTarget[ $i ] ) ) return FALSE;
            $movingTarget = $movingTarget[ $i ];
        }

        return isset( $movingTarget );
    }

    /**
     * Offset to retrieve
     * @link http://php.net/manual/en/arrayaccess.offsetget.php
     *
     * @param mixed $offset <p>
     * The offset to retrieve.
     * </p>
     *
     * @return mixed Can return all value types.
     * @since 5.0.0
     */
    public function offsetGet( $offset )
    {
        return $this->get( $offset );
    }

    /**
     * Offset to set
     * @link http://php.net/manual/en/arrayaccess.offsetset.php
     *
     * @param mixed $offset <p>
     * The offset to assign the value to.
     * </p>
     * @param mixed $value <p>
     * The value to set.
     * </p>
     *
     * @return void
     * @since 5.0.0
     */
    public function offsetSet( $offset, $value )
    {
        $this->set( $offset, $value );
    }

    /**
     * Offset to unset
     * @link http://php.net/manual/en/arrayaccess.offsetunset.php
     *
     * @param mixed $offset <p>
     * The offset to unset.
     * </p>
     *
     * @return void
     * @since 5.0.0
     */
    public function offsetUnset( $offset )
    {
        $movingTarget = &$this->data;
        $keys         = $this->parseDotNotation( $offset );
        $length       = count( $keys );

        foreach ( $keys as $i => $key )
        {
            if ( $i === $length - 1 )
            {
                unset( $movingTarget[ $key ] );
            }
            else
            {
                $movingTarget = &$movingTarget[ $key ];
            }
        }
    }

    /**
     * @return string
     */
    public function __toString()
    {
        return json_encode( $this );
    }
}
php-resta / resta-core

Push — master ( c91700...65feeb )

ArraySafe::offsetExists() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
