setnemo
diff --git a/‎.github/workflows/release.yml
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎.github/workflows/release.yml
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎CONTRIBUTING.md
Copy file name to clipboard
-1Lines changed: 0 additions & 1 deletion b/‎CONTRIBUTING.md
Copy file name to clipboard
-1Lines changed: 0 additions & 1 deletion
diff --git a/‎README.md
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎README.md
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎src/Asterisk.php
Copy file name to clipboard
+83-81Lines changed: 83 additions & 81 deletions b/‎src/Asterisk.php
Copy file name to clipboard
+83-81Lines changed: 83 additions & 81 deletions
@@ -8,7 +8,7 @@ jobs:
   release-please:
     runs-on: ubuntu-latest
     steps:
-      - uses: GoogleCloudPlatform/release-please-action@v2
+      - uses: GoogleCloudPlatform/release-please-action@main
         with:
           release-type: php
           package-name: release-please-action
@@ -10,4 +10,3 @@
 - check with command `make psalm` and if you have errors - fix it
 - commit you work, also write commit message according [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/)
 - push you work and create pull request
-- 
@@ -87,7 +87,7 @@ Asterisk has the following methods:
 - [get()](#get)
 - [has()](#has)
 - [isEmpty()](#isempty)
-- [merge()](#merge)
+- [merge()](#merge) // use Dot::merge(), **need write tests**, because used get(), set()
 - [mergeRecursive()](#mergerecursive)
 - [mergeRecursiveDistinct()](#mergerecursivedistinct)
 - [pull()](#pull)
 
@@ -18,6 +18,13 @@
 
 use Adbar\Dot;
 
+use function PHPUnit\Framework\isNull;
+
+/**
+ * Asterisk is provide asterisk notation access to arrays
+ *
+ * @package Setnemo
+ */
 class Asterisk extends Dot
 {
     /**
@@ -27,7 +34,7 @@ class Asterisk extends Dot
      * @param array|int|string $keys
      * @param mixed            $value
      */
-    public function add($keys, $value = null)
+    public function add($keys, $value = null): void
     {
         if (is_array($keys)) {
             foreach ($keys as $key => $value) {
@@ -42,7 +49,7 @@ public function add($keys, $value = null)
      * Delete the contents of a given key or keys
      *
      * @param array|int|string|null $keys
-     * @param bool $asterisk
+     * @param bool                  $asterisk
      */
     public function clear($keys = null, bool $asterisk = true): void
     {
@@ -62,7 +69,7 @@ public function clear($keys = null, bool $asterisk = true): void
      *
      * @param array|int|string $keys
      */
-    public function delete($keys)
+    public function delete($keys): void
     {
         $keys = (array) $keys;
         $affectedKeys = $this->getAffectedAndFilterKeys($keys);
@@ -72,29 +79,29 @@ public function delete($keys)
 
     /**
      * Return the value of a given key
-     * with star - all keys as array ['key.with.dot' => 'value']
+     * with asterisk - all keys as array ['key.with.dot' => 'value']
      *
      * @param int|string|null $key
-     * @param mixed $default
-     * @param bool $asterisk
+     * @param mixed           $default
+     * @param bool            $asterisk
      * @return mixed
      */
     public function get($key = null, $default = null, bool $asterisk = true)
     {
-        if (false === $asterisk || is_null($key) || !$this->keyHasStars($key)) {
+        if (false === $asterisk || is_null($key) || !$this->keyHasAsterisk($key)) {
             return parent::get($key, $default);
         }
 
-        return $this->getStarsAffectedKeys($key);
+        return $this->getAffectedKeys((string) $key);
     }
 
     /**
      * Check if a given key or keys exists
      * Also compare values with strict mode (default)
      *
      * @param array|int|string $keys
-     * @param null $value
-     * @param bool $strict
+     * @param null             $value
+     * @param bool             $strict
      * @return bool
      */
     public function has($keys, $value = null, bool $strict = true): bool
@@ -106,29 +113,29 @@ public function has($keys, $value = null, bool $strict = true): bool
 
         $affectedKeys = $this->getAffectedAndFilterKeys($keys);
 
-        if (null !== $value) {
+        if (!is_null($value)) {
             return $this->hasValueAndStrict(array_merge($affectedKeys, $keys), $value, $strict);
         }
 
-        return (bool) (!empty($affectedKeys) | parent::has($keys));
+        return (bool) ((int) !empty($affectedKeys) | (int) parent::has($keys));
     }
 
     /**
      * Set a given key / value pair or pairs
-     *
      * @param array|int|string $keys
      * @param mixed            $value
+     * @param bool             $asterisk
      */
-    public function set($keys, $value = null, bool $asterisk = true)
+    public function set($keys, $value = null, bool $asterisk = true): void
     {
         if (is_array($keys)) {
             foreach ($keys as $key => $value) {
                 $this->set($key, $value, $asterisk);
             }
             return;
         }
-        if ($asterisk && $this->keyHasStars($keys)) {
-            $affectedKeys = $this->prepareStarsAffectedKeys($keys, $value);
+        if ($asterisk && $this->keyHasAsterisk($keys)) {
+            $affectedKeys = $this->prepareAffectedKeys((string) $keys, $value);
             $this->set($affectedKeys, [], false);
             return;
         }
@@ -143,6 +150,35 @@ public function set($keys, $value = null, bool $asterisk = true)
         $items = $value;
     }
 
+    /**
+     * @param array $keys
+     * @param       $value
+     * @param bool  $strict
+     * @return bool
+     */
+    protected function hasValueAndStrict(
+        array $keys,
+        $value,
+        bool $strict
+    ): bool {
+        $nonStrictResult = 0;
+
+        foreach ($keys as $key) {
+            if ($value !== $this->get($key, null, false)) {
+                if (false === $strict) {
+                    $nonStrictResult++;
+                    continue;
+                }
+                return false;
+            }
+        }
+
+        if (!$strict) {
+            return $nonStrictResult !== count($keys);
+        }
+
+        return true;
+    }
 
     /**
      * Push a given value to the end of the array
@@ -151,56 +187,31 @@ public function set($keys, $value = null, bool $asterisk = true)
      * @param mixed $key
      * @param mixed $value
      */
-    public function push($key, $value = null, bool $asterisk = true)
+    public function push($key, $value = null, bool $asterisk = true): void
     {
-        if (is_null($value)) {
-            $this->items[] = $key;
-
-            return;
-        }
-
         $items = $this->get($key);
-        if ($asterisk && $this->keyHasStars($key)) {
-            $items = $this->prepareStarsAffectedKeys($key, $value);
+        if ($asterisk && $this->keyHasAsterisk($key)) {
+            $items = $this->prepareAffectedKeys($key, $value);
             foreach ($items as $key => $item) {
                 $changedItems = $this->get($key);
                 $this->set($key, array_merge((array)$changedItems, (array)$value), false);
             }
         } elseif (is_array($items) || is_null($items)) {
-            $items[] = $value;
+            $items[] = $value ?? [];
             $this->set($key, $items, $asterisk);
         }
     }
 
-    /**
-     * @param string $asteriskKey
-     * @param $value
-     * @return array
-     */
-    protected function prepareStarsAffectedKeys(string $asteriskKey, $value): array
-    {
-        $keys = $this->getStarsAffectedKeys($asteriskKey);
-        if ($this->isEmpty() && empty($keys)) {
-            return [$asteriskKey => $value];
-        }
-
-        foreach ($keys as $key => $v) {
-            $keys[$key] = $value;
-        }
-
-        return $keys;
-    }
-
     /**
      * @param array $keys
-     * @return array
+     * @return      array
      */
     protected function getAffectedAndFilterKeys(array &$keys): array
     {
         $affectedKeys = [];
         foreach ($keys as $it => $key) {
-            if ($this->keyHasStars($key)) {
-                $affectedKeys = array_merge($affectedKeys, $this->getStarsAffectedKeys($key, false) ?? []);
+            if ($this->keyHasAsterisk($key)) {
+                $affectedKeys = array_merge($affectedKeys, $this->getAffectedKeys($key, false) ?? []);
 
                 unset($keys[$it]);
             }
@@ -211,10 +222,10 @@ protected function getAffectedAndFilterKeys(array &$keys): array
 
     /**
      * @param string $asteriskKey
-     * @param bool $withValues
+     * @param bool   $withValues
      * @return array|null
      */
-    protected function getStarsAffectedKeys(string $asteriskKey, bool $withValues = true): ?array
+    protected function getAffectedKeys(string $asteriskKey, bool $withValues = true): ?array
     {
         $keys = $this->flatten();
 
@@ -227,8 +238,8 @@ protected function getStarsAffectedKeys(string $asteriskKey, bool $withValues =
         foreach ($keys as $key => $v) {
             $matches = [];
             preg_match_all($pattern, "$key", $matches);
-            $matchResult = $matches[0][0] ?? [];
-            if (!empty($matchResult) || $matchResult === "0") {
+            $matchResult = $matches[0][0] ?? '';
+            if (!empty($matchResult) || $matchResult === '0') {
                 $result = array_merge($result, $withValues ? [$matchResult => $v] : [$matchResult]);
             }
         }
@@ -237,43 +248,34 @@ protected function getStarsAffectedKeys(string $asteriskKey, bool $withValues =
     }
 
     /**
-     * @param array $keys
-     * @param $value
-     * @param bool $strict
+     * @param  $key
      * @return bool
      */
-    protected function hasValueAndStrict(
-        array $keys,
-        $value,
-        bool $strict
-    ): bool {
-        $nonStrictResult = 0;
-
-        foreach ($keys as $key) {
-            if ($value !== $this->get($key, null, false)) {
-                if (false === $strict) {
-                    $nonStrictResult++;
-                    continue;
-                }
-                return false;
-            }
-        }
-
-        if (!$strict) {
-            return $nonStrictResult !== count($keys);
-        }
+    protected function keyHasAsterisk($key): bool
+    {
+        $counter = array_count_values(explode('.', (string) $key) ?? []);
 
-        return true;
+        return (bool) ($counter['*'] ?? 0);
     }
 
     /**
-     * @param $key
-     * @return bool
+     * @param string $asteriskKey
+     * @param        $value
+     * @return array
      */
-    protected function keyHasStars($key): bool
+    protected function prepareAffectedKeys(string $asteriskKey, $value): array
     {
-        $counter = array_count_values(explode('.', (string) $key) ?? []);
+        $keys = $this->getAffectedKeys($asteriskKey);
+        if ($this->isEmpty() && empty($keys)) {
+            return [$asteriskKey => $value ?? []];
+        }
 
-        return (bool) ($counter['*'] ?? 0);
+        if (is_array($keys)) {
+            foreach ($keys as $key => $v) {
+                $keys[$key] = $value;
+            }
+        }
+
+        return $keys;
     }
 }