carno-php / redis

src/Chips/Compatible.php

<?php
/**
 * PHP Redis compatible
 * User: moyo
 * Date: 23/02/2018
 * Time: 2:30 PM
 */

namespace Carno\Redis\Chips;

trait Compatible
{
    /**
     * @param string $key
     * @param string $val
     * @param mixed $more
     * @return bool
     */
    public function set(string $key, string $val, $more = null)
    {
        $cmd = 'set';

        $args = [$key];

        if (is_null($more)) {
            // set(key, val)
            array_push($args, $val);
        } elseif (is_numeric($more)) {
            // set(key, val, timeout)
            $cmd = 'setex';
            array_push($args, $more, $val);
        } elseif (is_array($more) && $more) {

The expression $more of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            // set(key, val, [nx|xx, ex|px => timeout])
            array_push($args, $val, $more[0] ?? 'nx');

            if (isset($more['ex'])) {
                array_push($args, 'ex', $more['ex']);
            } elseif (isset($more['px'])) {
                array_push($args, 'px', $more['px']);
            }
        }

        return (yield $this->__call($cmd, $args)) === 'OK';

The expression yield $this->__call($cmd, $args) returns the type Generator which is incompatible with the documented return type boolean.

It seems like __call() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * @param string $key
     * @param array $map
     * @return bool
     */
    public function hMSet(string $key, array $map)
    {
        $args = [$key];

        foreach ($map as $k => $v) {
            array_push($args, $k, $v);
        }

        return (yield $this->__call('hmset', $args)) === 'OK';

The expression yield $this->__call('hmset', $args) returns the type Generator which is incompatible with the documented return type boolean.

    }

    /**
     * @param string $key
     * @param array $fds
     * @return array
     */
    public function hMGet(string $key, array $fds)
    {
        $args = $fds;

        array_unshift($args, $key);

        $got = yield $this->__call('hmget', $args);

The expression yield $this->__call('hmget', $args) returns the type Generator which is incompatible with the documented return type array.

        $map = [];

        foreach ($got as $slot => $val) {
            $map[$fds[$slot]] = $val;
        }

        return $map;
    }

    /**
     * @param string $key
     * @return array
     */
    public function hGetAll(string $key)
    {
        $got = yield $this->__call('hgetall', [$key]);

The expression yield $this->__call('hgetall', array($key)) returns the type Generator which is incompatible with the documented return type array.

        $map = [];

        for ($i = 0; $i < count($got); $i += 2) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

            $map[$got[$i]] = $got[$i + 1];
        }

        return $map;
    }

    /**
     * @param string $lua
     * @param array $args
     * @param int $keys
     * @return mixed
     */
    public function eval(string $lua, array $args = [], int $keys = 0)
    {
        array_unshift($args, $lua, $keys);

        return $this->__call('eval', $args);
    }
}