Code

[+]: Code improvements

Author: microThread

README.md

@@ -19,13 +19,14 @@ DotArray::create(['config' => ['some.dotted.key' => 'value']])->get('config.{som
 
 ## Installing
 
-- **via "composer require"**
-    ```shell
-    composer require binary-cube/dot-array
+- **via "composer require"**:
+
+    ``` shell
+        composer require binary-cube/dot-array
     ```
 
-- **via composer (manually)**
-    
+- **via composer (manually)**:
+
     If you're using Composer to manage dependencies, you can include the following
     in your `composer.json` file:
 
@@ -39,107 +40,106 @@ DotArray::create(['config' => ['some.dotted.key' => 'value']])->get('config.{som
 
 ## Usage
 
-
->#### REMEMBER: YOU NEED TO KNOW YOUR DATA!
->#### DotArray::get() can return a new instance of DotArray in case the accessed path is an array or it will return the raw data value or the default given value.
+>##### REMEMBER: YOU NEED TO KNOW YOUR DATA
+>##### DotArray::get() can return a new instance of DotArray in case the accessed path is an array or it will return the raw data value or the default given value
 
 - **instantiation**:
-    - ```php
+    -   ```php
         new DotArray($array);
         DotArray::create($array);
         DotArray::createFromJson($jsonString);
-      ```
+        ```
 
 - **get**:
-    - ```php
+    -   ```php
         // Because the key `sci-fi & fantasy` is array the returning value it will be a new instance of DotArray.
         $dot('books.{sci-fi & fantasy}');
-  
+        
         // Because the price is not an array, the result will be raw data, float in this case.
         $dot('books.{sci-fi & fantasy}.0.price');
-    
+        
         // Accessing the raw array.
         $dot('books.{sci-fi & fantasy}')->toArray();
         $dot->get('books.{sci-fi & fantasy}')->toArray();
-  
+        
         // Accessing the last leaf and getting the raw data.
         $dot('books.{sci-fi & fantasy}.0.name');
         $dot->get('books.{sci-fi & fantasy}.0.name');
 
         // Vanilla PHP.
         $dot('books.{sci-fi & fantasy}.0.name');
         $dot['books']['sci-fi & fantasy'][0]['name'];
-      ```
+        ```
 
 - **get :: more-complex**:
-    - ```php
+    -   ```php
         // Using dotted key and accessing without getting confused.
         // Allowed tokens for keeping the names with dot(.) togethers are: '', "", [], (), {}
         $dot->get('config.{elastic-search}.\'v5.0\'.host')
         $dot->get('config.{elastic-search}."v5.0".host')
         $dot->get('config.{elastic-search}.[v5.0].host')
         $dot->get('config.{elastic-search}.(v5.0).host')
         $dot->get('config.{elastic-search}.{v5.0}.host')
-      ```
+        ```
 
 - **set**:
-    - ```php
+    -   ```php
         $dot->set('books.{sci-fi & fantasy}.0.name', 'New Name');
-  
+        
         // Vanilla PHP.
         $dot['books.{sci-fi & fantasy}.0.name'] = 'New Name';
         $dot['books']['sci-fi & fantasy'][0]['name'] = 'New Name';
-      ```
+        ```
 
 - **clear** *(empty array <=> [])*:
-    - ```php
+    -   ```php
         $dot->clear('books.{sci-fi & fantasy}');
         $dot->clear('books.{sci-fi & fantasy}', null);
         $dot->clear('books.{sci-fi & fantasy}.0.name', null);
-  
+        
         // Multiple keys.
         $dot->clear([
           'books.{sci-fi & fantasy}',
           'books.{childre\'s books}'
         ]);
-  
+        
         // Vanilla PHP.
         $dot['books.{sci-fi & fantasy}'] = [];
-      ```
+        ```
 
 - **delete** *(unset(...))*:
-    - ```php
+    -   ```php
         $dot->delete('books.{sci-fi & fantasy}');
         $dot->delete('books.{sci-fi & fantasy}.0.name');
         $dot->delete(['books.{sci-fi & fantasy}.0', 'books.{childre\'s books}.0']);
-      ```
+        ```
 
 - **find**:
-    - ```php 
+    -   ```php
         /*
             Find the first item in an array that passes the truth test, otherwise return false
             The signature of the callable must be: `function ($value, $key)`.
         */
         $book = $dot->get('books.{childre\'s books}')->find(function ($value, $key) {
            return $value['price'] > 0;
         });
-      ```
+        ```
 
 - **filter**:
-    - ```php 
+    -   ```php
         /*
             Use a callable function to filter through items.
             The signature of the callable must be: `function ($value, $key)`
         */
         $books = $dot->get('books.{childre\'s books}')->filter(function ($value, $key) {
-           return $value['name'] === 'Harry Potter and the Order of the Phoenix';
+            return $value['name'] === 'Harry Potter and the Order of the Phoenix';
         });
         
         $books->toArray();
-      ```
+        ```
 
 - **where**:
-    - ```php
+    -   ```php
         /*
             Allowed Operations:
                 =, == ===, !=, !==, <, >, <=, >=,
@@ -161,9 +161,9 @@ DotArray::create(['config' => ['some.dotted.key' => 'value']])->get('config.{som
         $books = $dot->get('books.{childre\'s books}')->where(function ($value, $key) {
             return $value['name'] === 'Harry Potter and the Order of the Phoenix';
         });
-      ```
+        ```
 
-#### Data Sample:
+### Data Sample:
 
 ```php
 $dummyArray = [

phpunit.xml.dist

@@ -28,10 +28,11 @@
 
 
     <logging>
-        <log type="tap" target="build/phpunit/report.tap"/>
-        <log type="junit" target="build/phpunit/report.junit.xml"/>
-        <log type="coverage-html" target="build/phpunit/coverage"/>
-        <log type="coverage-text" target="build/phpunit/coverage.txt"/>
-        <log type="coverage-clover" target="build/phpunit/logs/clover.xml"/>
+        <log type="tap"     target="build/phpunit/report.tap"/>
+        <log type="junit"   target="build/phpunit/report.junit.xml"/>
+
+        <log type="coverage-html"   target="build/phpunit/coverage/html"/>
+        <log type="coverage-text"   target="build/phpunit/coverage/txt"/>
+        <log type="coverage-clover" target="build/phpunit/coverage/xml"/>
     </logging>
 </phpunit>

src/DotArray.php

@@ -254,12 +254,12 @@ protected function segmentsToKey(array $segments)
 
 
     /**
-     * @param array|DotArray|mixed $a
-     * @param array|DotArray|mixed $b
+     * @param array|DotArray|mixed      $array1
+     * @param null|array|DotArray|mixed $array2
      *
      * @return array
      */
-    protected static function mergeRecursive($a, $b)
+    protected static function mergeRecursive($array1, $array2 = null)
     {
         $args = \func_get_args();
         $res  = \array_shift($args);
@@ -301,12 +301,12 @@ protected static function mergeRecursive($a, $b)
      * For integer-keyed elements, the elements from the latter array will
      * be appended to the former array.
      *
-     * @param array|DotArray|mixed $a Array to be merged from. You can specify additional
-     *                                arrays via third argument, fourth argument etc.
+     * @param array|DotArray|mixed $array Array to be merged from. You can specify additional
+     *                                    arrays via second argument, third argument, fourth argument etc.
      *
      * @return static
      */
-    public function merge($a)
+    public function merge($array)
     {
         $this->items = \call_user_func_array(
             [
@@ -709,17 +709,15 @@ public function where($criteria)
                 foreach ($filters as $filter) {
                     // Search for operation.
                     if (\in_array($operation, $filter['tokens'])) {
-                        $closure = \Closure::fromCallable(
-                            function ($item) use ($filter, $property, $value) {
-                                $item = (array) $item;
+                        $closure = function ($item) use ($filter, $property, $value) {
+                            $item = (array) $item;
 
-                                if (!array_key_exists($property, $item)) {
-                                    return false;
-                                }
-
-                                return $filter['closure']($item, $property, $value);
+                            if (!array_key_exists($property, $item)) {
+                                return false;
                             }
-                        );
+
+                            return $filter['closure']($item, $property, $value);
+                        };
 
                         break;
                     }//end if
@@ -729,11 +727,9 @@ function ($item) use ($filter, $property, $value) {
 
         // Dummy closure if nothing is provided.
         if (empty($closure)) {
-            $closure = \Closure::fromCallable(
-                function () {
-                    return true;
-                }
-            );
+            $closure = function () {
+                return true;
+            };
         }
 
         return $this->filter($closure, ARRAY_FILTER_USE_BOTH);