gravityview / GravityView

includes/fields/class-gravityview-field-custom.php

Spacing +9 added lines, -9 removed lines

@@ -56,7 +56,7 @@ 
 	 */
 	public function add_default_field( $entry_default_fields, $form = array(), $zone = '' ) {
 
-		$entry_default_fields['custom']	= array(
+		$entry_default_fields[ 'custom' ] = array(
 			'label'	=> $this->label,
 			'type'	=> $this->name,
 			'desc'	=> $this->description,
@@ -69,7 +69,7 @@ 
 
 	public function field_options( $field_options, $template_id, $field_id, $context, $input_type, $form_id ) {
 
-		unset ( $field_options['search_filter'], $field_options['show_as_link'], $field_options['new_window'] );
+		unset ( $field_options[ 'search_filter' ], $field_options[ 'show_as_link' ], $field_options[ 'new_window' ] );
 
 		$new_fields = array(
 			'content' => array(
@@ -112,7 +112,7 @@ 
 		);
 
 		if ( 'edit' === $context ) {
-			unset( $field_options['custom_label'], $field_options['show_label'], $field_options['allow_edit_cap'], $new_fields['wpautop'], $new_fields['oembed'] );
+			unset( $field_options[ 'custom_label' ], $field_options[ 'show_label' ], $field_options[ 'allow_edit_cap' ], $new_fields[ 'wpautop' ], $new_fields[ 'oembed' ] );
 		}
 
 		return $new_fields + $field_options;
@@ -146,9 +146,9 @@ 
 
 		// Loop through the configured Edit Entry fields and add Custom Content fields if there are any
 		// TODO: Make this available to other custom GV field types
-		foreach ( (array) $edit_fields as $edit_field ) {
+		foreach ( (array)$edit_fields as $edit_field ) {
 
-			if( 'custom' === \GV\Utils::get( $edit_field, 'id') ) {
+			if ( 'custom' === \GV\Utils::get( $edit_field, 'id' ) ) {
 
 				$field_data = array(
 					'label' => \GV\Utils::get( $edit_field, 'custom_label' ),
@@ -162,13 +162,13 @@ 
 					$field_data[ $key ] = GravityView_Merge_Tags::replace_variables( $field_datum, $form, $entry_data, false, false );
 				}
 
-				$field_data['cssClass'] = \GV\Utils::get( $edit_field, 'custom_class' );
+				$field_data[ 'cssClass' ] = \GV\Utils::get( $edit_field, 'custom_class' );
 
-				$new_fields[] = new GF_Field_HTML( $field_data );
+				$new_fields[ ] = new GF_Field_HTML( $field_data );
 
 			} else {
-				if( isset( $fields[ $i ] ) ) {
-					$new_fields[] =  $fields[ $i ];
+				if ( isset( $fields[ $i ] ) ) {
+					$new_fields[ ] = $fields[ $i ];
 				}
 				$i++;
 			}

includes/plugin-and-theme-hooks/class-gravityview-plugin-hooks-gravity-forms-signature.php

Spacing +6 added lines, -6 removed lines

@@ -53,7 +53,7 @@ 
 		$signature_fields = GFAPI::get_fields_by_type( $form, 'signature' );
 
 		foreach ( $signature_fields as $field ) {
-			unset( $_POST["input_{$field->id}"] );
+			unset( $_POST[ "input_{$field->id}" ] );
 		}
 	}
 
@@ -72,19 +72,19 @@ 
 	 */
 	function edit_entry_field_input( $field_content = '', $field = null, $value = '', $lead_id = 0, $form_id = 0 ) {
 
-		$context = function_exists('gravityview_get_context') ? gravityview_get_context() : '';
+		$context = function_exists( 'gravityview_get_context' ) ? gravityview_get_context() : '';
 
-		if( 'signature' !== $field->type || 'edit' !== $context ) {
+		if ( 'signature' !== $field->type || 'edit' !== $context ) {
 			return $field_content;
 		}
 
 		// We need to fetch a fresh version of the entry, since the saved entry hasn't refreshed in GV yet.
 		$entry = GravityView_View::getInstance()->getCurrentEntry();
-		$entry = GFAPI::get_entry( $entry['id'] );
+		$entry = GFAPI::get_entry( $entry[ 'id' ] );
 		$entry_value = \GV\Utils::get( $entry, $field->id );
 
-		$_POST["input_{$field->id}"] = $entry_value; // Used when Edit Entry form *is* submitted
-		$_POST["input_{$form_id}_{$field->id}_signature_filename"] = $entry_value; // Used when Edit Entry form *is not* submitted
+		$_POST[ "input_{$field->id}" ] = $entry_value; // Used when Edit Entry form *is* submitted
+		$_POST[ "input_{$form_id}_{$field->id}_signature_filename" ] = $entry_value; // Used when Edit Entry form *is not* submitted
 
 		return ''; // Return empty string to force using $_POST values instead
 	}

vendor/illuminate/support/Traits/Macroable.php

Spacing +17 added lines, -17 removed lines

@@ -12,7 +12,7 @@ 
      *
      * @var array
      */
-    protected static $macros = [];
+    protected static $macros = [ ];
 
     /**
      * Register a custom macro.
@@ -21,9 +21,9 @@ 
      * @param  callable  $macro
      * @return void
      */
-    public static function macro($name, callable $macro)
+    public static function macro( $name, callable $macro )
     {
-        static::$macros[$name] = $macro;
+        static::$macros[ $name ] = $macro;
     }
 
     /**
@@ -32,9 +32,9 @@ 
      * @param  string  $name
      * @return bool
      */
-    public static function hasMacro($name)
+    public static function hasMacro( $name )
     {
-        return isset(static::$macros[$name]);
+        return isset( static::$macros[ $name ] );
     }
 
     /**
@@ -46,17 +46,17 @@ 
      *
      * @throws \BadMethodCallException
      */
-    public static function __callStatic($method, $parameters)
+    public static function __callStatic( $method, $parameters )
     {
-        if (! static::hasMacro($method)) {
-            throw new BadMethodCallException("Method {$method} does not exist.");
+        if ( ! static::hasMacro( $method ) ) {
+            throw new BadMethodCallException( "Method {$method} does not exist." );
         }
 
-        if (static::$macros[$method] instanceof Closure) {
-            return call_user_func_array(Closure::bind(static::$macros[$method], null, static::class), $parameters);
+        if ( static::$macros[ $method ] instanceof Closure ) {
+            return call_user_func_array( Closure::bind( static::$macros[ $method ], null, static::class ), $parameters );
         }
 
-        return call_user_func_array(static::$macros[$method], $parameters);
+        return call_user_func_array( static::$macros[ $method ], $parameters );
     }
 
     /**
@@ -68,16 +68,16 @@ 
      *
      * @throws \BadMethodCallException
      */
-    public function __call($method, $parameters)
+    public function __call( $method, $parameters )
     {
-        if (! static::hasMacro($method)) {
-            throw new BadMethodCallException("Method {$method} does not exist.");
+        if ( ! static::hasMacro( $method ) ) {
+            throw new BadMethodCallException( "Method {$method} does not exist." );
         }
 
-        if (static::$macros[$method] instanceof Closure) {
-            return call_user_func_array(static::$macros[$method]->bindTo($this, static::class), $parameters);
+        if ( static::$macros[ $method ] instanceof Closure ) {
+            return call_user_func_array( static::$macros[ $method ]->bindTo( $this, static::class ), $parameters );
         }
 
-        return call_user_func_array(static::$macros[$method], $parameters);
+        return call_user_func_array( static::$macros[ $method ], $parameters );
     }
 }

vendor/illuminate/support/HigherOrderCollectionProxy.php

Spacing +7 added lines, -7 removed lines

@@ -28,7 +28,7 @@ 
      * @param  string  $method
      * @return void
      */
-    public function __construct(Collection $collection, $method)
+    public function __construct( Collection $collection, $method )
     {
         $this->method = $method;
         $this->collection = $collection;
@@ -40,10 +40,10 @@ 
      * @param  string  $key
      * @return mixed
      */
-    public function __get($key)
+    public function __get( $key )
     {
-        return $this->collection->{$this->method}(function ($value) use ($key) {
-            return is_array($value) ? $value[$key] : $value->{$key};
+        return $this->collection->{$this->method}( function( $value ) use ( $key ) {
+            return is_array( $value ) ? $value[ $key ] : $value->{$key};
         });
     }
 
@@ -54,10 +54,10 @@ 
      * @param  array  $parameters
      * @return mixed
      */
-    public function __call($method, $parameters)
+    public function __call( $method, $parameters )
     {
-        return $this->collection->{$this->method}(function ($value) use ($method, $parameters) {
-            return $value->{$method}(...$parameters);
+        return $this->collection->{$this->method}( function( $value ) use ( $method, $parameters ) {
+            return $value->{$method}( ...$parameters );
         });
     }
 }

vendor/illuminate/support/Collection.php

Spacing +365 added lines, -365 removed lines

@@ -23,7 +23,7 @@ 
      *
      * @var array
      */
-    protected $items = [];
+    protected $items = [ ];
 
     /**
      * The methods that can be proxied.
@@ -41,9 +41,9 @@ 
      * @param  mixed  $items
      * @return void
      */
-    public function __construct($items = [])
+    public function __construct( $items = [ ] )
     {
-        $this->items = $this->getArrayableItems($items);
+        $this->items = $this->getArrayableItems( $items );
     }
 
     /**
@@ -52,9 +52,9 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public static function make($items = [])
+    public static function make( $items = [ ] )
     {
-        return new static($items);
+        return new static( $items );
     }
 
     /**
@@ -64,17 +64,17 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public static function times($number, callable $callback = null)
+    public static function times( $number, callable $callback = null )
     {
-        if ($number < 1) {
+        if ( $number < 1 ) {
             return new static;
         }
 
-        if (is_null($callback)) {
-            return new static(range(1, $number));
+        if ( is_null( $callback ) ) {
+            return new static( range( 1, $number ) );
         }
 
-        return (new static(range(1, $number)))->map($callback);
+        return ( new static( range( 1, $number ) ) )->map( $callback );
     }
 
     /**
@@ -93,10 +93,10 @@ 
      * @param  callable|string|null  $callback
      * @return mixed
      */
-    public function avg($callback = null)
+    public function avg( $callback = null )
     {
-        if ($count = $this->count()) {
-            return $this->sum($callback) / $count;
+        if ( $count = $this->count() ) {
+            return $this->sum( $callback ) / $count;
         }
     }
 
@@ -106,9 +106,9 @@ 
      * @param  callable|string|null  $callback
      * @return mixed
      */
-    public function average($callback = null)
+    public function average( $callback = null )
     {
-        return $this->avg($callback);
+        return $this->avg( $callback );
     }
 
     /**
@@ -117,26 +117,26 @@ 
      * @param  null $key
      * @return mixed
      */
-    public function median($key = null)
+    public function median( $key = null )
     {
         $count = $this->count();
 
-        if ($count == 0) {
+        if ( $count == 0 ) {
             return;
         }
 
-        $values = with(isset($key) ? $this->pluck($key) : $this)
+        $values = with( isset( $key ) ? $this->pluck( $key ) : $this )
                     ->sort()->values();
 
-        $middle = (int) ($count / 2);
+        $middle = (int)( $count / 2 );
 
-        if ($count % 2) {
-            return $values->get($middle);
+        if ( $count % 2 ) {
+            return $values->get( $middle );
         }
 
-        return (new static([
-            $values->get($middle - 1), $values->get($middle),
-        ]))->average();
+        return ( new static( [
+            $values->get( $middle - 1 ), $values->get( $middle ),
+        ] ) )->average();
     }
 
     /**
@@ -145,27 +145,27 @@ 
      * @param  mixed  $key
      * @return array|null
      */
-    public function mode($key = null)
+    public function mode( $key = null )
     {
         $count = $this->count();
 
-        if ($count == 0) {
+        if ( $count == 0 ) {
             return;
         }
 
-        $collection = isset($key) ? $this->pluck($key) : $this;
+        $collection = isset( $key ) ? $this->pluck( $key ) : $this;
 
         $counts = new self;
 
-        $collection->each(function ($value) use ($counts) {
-            $counts[$value] = isset($counts[$value]) ? $counts[$value] + 1 : 1;
+        $collection->each( function( $value ) use ( $counts ) {
+            $counts[ $value ] = isset( $counts[ $value ] ) ? $counts[ $value ] + 1 : 1;
         });
 
         $sorted = $counts->sort();
 
         $highestValue = $sorted->last();
 
-        return $sorted->filter(function ($value) use ($highestValue) {
+        return $sorted->filter( function( $value ) use ( $highestValue ) {
             return $value == $highestValue;
         })->sort()->keys()->all();
     }
@@ -177,7 +177,7 @@ 
      */
     public function collapse()
     {
-        return new static(Arr::collapse($this->items));
+        return new static( Arr::collapse( $this->items ) );
     }
 
     /**
@@ -188,23 +188,23 @@ 
      * @param  mixed  $value
      * @return bool
      */
-    public function contains($key, $operator = null, $value = null)
+    public function contains( $key, $operator = null, $value = null )
     {
-        if (func_num_args() == 1) {
-            if ($this->useAsCallable($key)) {
-                return ! is_null($this->first($key));
+        if ( func_num_args() == 1 ) {
+            if ( $this->useAsCallable( $key ) ) {
+                return ! is_null( $this->first( $key ) );
             }
 
-            return in_array($key, $this->items);
+            return in_array( $key, $this->items );
         }
 
-        if (func_num_args() == 2) {
+        if ( func_num_args() == 2 ) {
             $value = $operator;
 
             $operator = '=';
         }
 
-        return $this->contains($this->operatorForWhere($key, $operator, $value));
+        return $this->contains( $this->operatorForWhere( $key, $operator, $value ) );
     }
 
     /**
@@ -214,19 +214,19 @@ 
      * @param  mixed  $value
      * @return bool
      */
-    public function containsStrict($key, $value = null)
+    public function containsStrict( $key, $value = null )
     {
-        if (func_num_args() == 2) {
-            return $this->contains(function ($item) use ($key, $value) {
-                return data_get($item, $key) === $value;
+        if ( func_num_args() == 2 ) {
+            return $this->contains( function( $item ) use ( $key, $value ) {
+                return data_get( $item, $key ) === $value;
             });
         }
 
-        if ($this->useAsCallable($key)) {
-            return ! is_null($this->first($key));
+        if ( $this->useAsCallable( $key ) ) {
+            return ! is_null( $this->first( $key ) );
         }
 
-        return in_array($key, $this->items, true);
+        return in_array( $key, $this->items, true );
     }
 
     /**
@@ -235,11 +235,11 @@ 
      * @param  mixed  ...$lists
      * @return static
      */
-    public function crossJoin(...$lists)
+    public function crossJoin( ...$lists )
     {
-        return new static(Arr::crossJoin(
-            $this->items, ...array_map([$this, 'getArrayableItems'], $lists)
-        ));
+        return new static( Arr::crossJoin(
+            $this->items, ...array_map( [ $this, 'getArrayableItems' ], $lists )
+        ) );
     }
 
     /**
@@ -248,9 +248,9 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function diff($items)
+    public function diff( $items )
     {
-        return new static(array_diff($this->items, $this->getArrayableItems($items)));
+        return new static( array_diff( $this->items, $this->getArrayableItems( $items ) ) );
     }
 
     /**
@@ -259,9 +259,9 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function diffAssoc($items)
+    public function diffAssoc( $items )
     {
-        return new static(array_diff_assoc($this->items, $this->getArrayableItems($items)));
+        return new static( array_diff_assoc( $this->items, $this->getArrayableItems( $items ) ) );
     }
 
     /**
@@ -270,9 +270,9 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function diffKeys($items)
+    public function diffKeys( $items )
     {
-        return new static(array_diff_key($this->items, $this->getArrayableItems($items)));
+        return new static( array_diff_key( $this->items, $this->getArrayableItems( $items ) ) );
     }
 
     /**
@@ -281,10 +281,10 @@ 
      * @param  callable  $callback
      * @return $this
      */
-    public function each(callable $callback)
+    public function each( callable $callback )
     {
-        foreach ($this->items as $key => $item) {
-            if ($callback($item, $key) === false) {
+        foreach ( $this->items as $key => $item ) {
+            if ( $callback( $item, $key ) === false ) {
                 break;
             }
         }
@@ -298,10 +298,10 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public function eachSpread(callable $callback)
+    public function eachSpread( callable $callback )
     {
-        return $this->each(function ($chunk) use ($callback) {
-            return $callback(...$chunk);
+        return $this->each( function( $chunk ) use ( $callback ) {
+            return $callback( ...$chunk );
         });
     }
 
@@ -313,13 +313,13 @@ 
      * @param  mixed  $value
      * @return bool
      */
-    public function every($key, $operator = null, $value = null)
+    public function every( $key, $operator = null, $value = null )
     {
-        if (func_num_args() == 1) {
-            $callback = $this->valueRetriever($key);
+        if ( func_num_args() == 1 ) {
+            $callback = $this->valueRetriever( $key );
 
-            foreach ($this->items as $k => $v) {
-                if (! $callback($v, $k)) {
+            foreach ( $this->items as $k => $v ) {
+                if ( ! $callback( $v, $k ) ) {
                     return false;
                 }
             }
@@ -327,13 +327,13 @@ 
             return true;
         }
 
-        if (func_num_args() == 2) {
+        if ( func_num_args() == 2 ) {
             $value = $operator;
 
             $operator = '=';
         }
 
-        return $this->every($this->operatorForWhere($key, $operator, $value));
+        return $this->every( $this->operatorForWhere( $key, $operator, $value ) );
     }
 
     /**
@@ -342,11 +342,11 @@ 
      * @param  mixed  $keys
      * @return static
      */
-    public function except($keys)
+    public function except( $keys )
     {
-        $keys = is_array($keys) ? $keys : func_get_args();
+        $keys = is_array( $keys ) ? $keys : func_get_args();
 
-        return new static(Arr::except($this->items, $keys));
+        return new static( Arr::except( $this->items, $keys ) );
     }
 
     /**
@@ -355,13 +355,13 @@ 
      * @param  callable|null  $callback
      * @return static
      */
-    public function filter(callable $callback = null)
+    public function filter( callable $callback = null )
     {
-        if ($callback) {
-            return new static(Arr::where($this->items, $callback));
+        if ( $callback ) {
+            return new static( Arr::where( $this->items, $callback ) );
         }
 
-        return new static(array_filter($this->items));
+        return new static( array_filter( $this->items ) );
     }
 
     /**
@@ -372,12 +372,12 @@ 
      * @param  callable  $default
      * @return mixed
      */
-    public function when($value, callable $callback, callable $default = null)
+    public function when( $value, callable $callback, callable $default = null )
     {
-        if ($value) {
-            return $callback($this);
-        } elseif ($default) {
-            return $default($this);
+        if ( $value ) {
+            return $callback( $this );
+        } elseif ( $default ) {
+            return $default( $this );
         }
 
         return $this;
@@ -391,9 +391,9 @@ 
      * @param  callable  $default
      * @return mixed
      */
-    public function unless($value, callable $callback, callable $default = null)
+    public function unless( $value, callable $callback, callable $default = null )
     {
-        return $this->when(! $value, $callback, $default);
+        return $this->when( ! $value, $callback, $default );
     }
 
     /**
@@ -404,15 +404,15 @@ 
      * @param  mixed  $value
      * @return static
      */
-    public function where($key, $operator, $value = null)
+    public function where( $key, $operator, $value = null )
     {
-        if (func_num_args() == 2) {
+        if ( func_num_args() == 2 ) {
             $value = $operator;
 
             $operator = '=';
         }
 
-        return $this->filter($this->operatorForWhere($key, $operator, $value));
+        return $this->filter( $this->operatorForWhere( $key, $operator, $value ) );
     }
 
     /**
@@ -423,12 +423,12 @@ 
      * @param  mixed  $value
      * @return \Closure
      */
-    protected function operatorForWhere($key, $operator, $value)
+    protected function operatorForWhere( $key, $operator, $value )
     {
-        return function ($item) use ($key, $operator, $value) {
-            $retrieved = data_get($item, $key);
+        return function( $item ) use ( $key, $operator, $value ) {
+            $retrieved = data_get( $item, $key );
 
-            switch ($operator) {
+            switch ( $operator ) {
                 default:
                 case '=':
                 case '==':  return $retrieved == $value;
@@ -451,9 +451,9 @@ 
      * @param  mixed  $value
      * @return static
      */
-    public function whereStrict($key, $value)
+    public function whereStrict( $key, $value )
     {
-        return $this->where($key, '===', $value);
+        return $this->where( $key, '===', $value );
     }
 
     /**
@@ -464,12 +464,12 @@ 
      * @param  bool  $strict
      * @return static
      */
-    public function whereIn($key, $values, $strict = false)
+    public function whereIn( $key, $values, $strict = false )
     {
-        $values = $this->getArrayableItems($values);
+        $values = $this->getArrayableItems( $values );
 
-        return $this->filter(function ($item) use ($key, $values, $strict) {
-            return in_array(data_get($item, $key), $values, $strict);
+        return $this->filter( function( $item ) use ( $key, $values, $strict ) {
+            return in_array( data_get( $item, $key ), $values, $strict );
         });
     }
 
@@ -480,9 +480,9 @@ 
      * @param  mixed  $values
      * @return static
      */
-    public function whereInStrict($key, $values)
+    public function whereInStrict( $key, $values )
     {
-        return $this->whereIn($key, $values, true);
+        return $this->whereIn( $key, $values, true );
     }
 
     /**
@@ -493,12 +493,12 @@ 
      * @param  bool  $strict
      * @return static
      */
-    public function whereNotIn($key, $values, $strict = false)
+    public function whereNotIn( $key, $values, $strict = false )
     {
-        $values = $this->getArrayableItems($values);
+        $values = $this->getArrayableItems( $values );
 
-        return $this->reject(function ($item) use ($key, $values, $strict) {
-            return in_array(data_get($item, $key), $values, $strict);
+        return $this->reject( function( $item ) use ( $key, $values, $strict ) {
+            return in_array( data_get( $item, $key ), $values, $strict );
         });
     }
 
@@ -509,9 +509,9 @@ 
      * @param  mixed  $values
      * @return static
      */
-    public function whereNotInStrict($key, $values)
+    public function whereNotInStrict( $key, $values )
     {
-        return $this->whereNotIn($key, $values, true);
+        return $this->whereNotIn( $key, $values, true );
     }
 
     /**
@@ -521,9 +521,9 @@ 
      * @param  mixed  $default
      * @return mixed
      */
-    public function first(callable $callback = null, $default = null)
+    public function first( callable $callback = null, $default = null )
     {
-        return Arr::first($this->items, $callback, $default);
+        return Arr::first( $this->items, $callback, $default );
     }
 
     /**
@@ -532,9 +532,9 @@ 
      * @param  int  $depth
      * @return static
      */
-    public function flatten($depth = INF)
+    public function flatten( $depth = INF )
     {
-        return new static(Arr::flatten($this->items, $depth));
+        return new static( Arr::flatten( $this->items, $depth ) );
     }
 
     /**
@@ -544,7 +544,7 @@ 
      */
     public function flip()
     {
-        return new static(array_flip($this->items));
+        return new static( array_flip( $this->items ) );
     }
 
     /**
@@ -553,10 +553,10 @@ 
      * @param  string|array  $keys
      * @return $this
      */
-    public function forget($keys)
+    public function forget( $keys )
     {
-        foreach ((array) $keys as $key) {
-            $this->offsetUnset($key);
+        foreach ( (array)$keys as $key ) {
+            $this->offsetUnset( $key );
         }
 
         return $this;
@@ -569,13 +569,13 @@ 
      * @param  mixed  $default
      * @return mixed
      */
-    public function get($key, $default = null)
+    public function get( $key, $default = null )
     {
-        if ($this->offsetExists($key)) {
-            return $this->items[$key];
+        if ( $this->offsetExists( $key ) ) {
+            return $this->items[ $key ];
         }
 
-        return value($default);
+        return value( $default );
     }
 
     /**
@@ -585,31 +585,31 @@ 
      * @param  bool  $preserveKeys
      * @return static
      */
-    public function groupBy($groupBy, $preserveKeys = false)
+    public function groupBy( $groupBy, $preserveKeys = false )
     {
-        $groupBy = $this->valueRetriever($groupBy);
+        $groupBy = $this->valueRetriever( $groupBy );
 
-        $results = [];
+        $results = [ ];
 
-        foreach ($this->items as $key => $value) {
-            $groupKeys = $groupBy($value, $key);
+        foreach ( $this->items as $key => $value ) {
+            $groupKeys = $groupBy( $value, $key );
 
-            if (! is_array($groupKeys)) {
-                $groupKeys = [$groupKeys];
+            if ( ! is_array( $groupKeys ) ) {
+                $groupKeys = [ $groupKeys ];
             }
 
-            foreach ($groupKeys as $groupKey) {
-                $groupKey = is_bool($groupKey) ? (int) $groupKey : $groupKey;
+            foreach ( $groupKeys as $groupKey ) {
+                $groupKey = is_bool( $groupKey ) ? (int)$groupKey : $groupKey;
 
-                if (! array_key_exists($groupKey, $results)) {
-                    $results[$groupKey] = new static;
+                if ( ! array_key_exists( $groupKey, $results ) ) {
+                    $results[ $groupKey ] = new static;
                 }
 
-                $results[$groupKey]->offsetSet($preserveKeys ? $key : null, $value);
+                $results[ $groupKey ]->offsetSet( $preserveKeys ? $key : null, $value );
             }
         }
 
-        return new static($results);
+        return new static( $results );
     }
 
     /**
@@ -618,23 +618,23 @@ 
      * @param  callable|string  $keyBy
      * @return static
      */
-    public function keyBy($keyBy)
+    public function keyBy( $keyBy )
     {
-        $keyBy = $this->valueRetriever($keyBy);
+        $keyBy = $this->valueRetriever( $keyBy );
 
-        $results = [];
+        $results = [ ];
 
-        foreach ($this->items as $key => $item) {
-            $resolvedKey = $keyBy($item, $key);
+        foreach ( $this->items as $key => $item ) {
+            $resolvedKey = $keyBy( $item, $key );
 
-            if (is_object($resolvedKey)) {
-                $resolvedKey = (string) $resolvedKey;
+            if ( is_object( $resolvedKey ) ) {
+                $resolvedKey = (string)$resolvedKey;
             }
 
-            $results[$resolvedKey] = $item;
+            $results[ $resolvedKey ] = $item;
         }
 
-        return new static($results);
+        return new static( $results );
     }
 
     /**
@@ -643,9 +643,9 @@ 
      * @param  mixed  $key
      * @return bool
      */
-    public function has($key)
+    public function has( $key )
     {
-        return $this->offsetExists($key);
+        return $this->offsetExists( $key );
     }
 
     /**
@@ -655,15 +655,15 @@ 
      * @param  string  $glue
      * @return string
      */
-    public function implode($value, $glue = null)
+    public function implode( $value, $glue = null )
     {
         $first = $this->first();
 
-        if (is_array($first) || is_object($first)) {
-            return implode($glue, $this->pluck($value)->all());
+        if ( is_array( $first ) || is_object( $first ) ) {
+            return implode( $glue, $this->pluck( $value )->all() );
         }
 
-        return implode($value, $this->items);
+        return implode( $value, $this->items );
     }
 
     /**
@@ -672,9 +672,9 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function intersect($items)
+    public function intersect( $items )
     {
-        return new static(array_intersect($this->items, $this->getArrayableItems($items)));
+        return new static( array_intersect( $this->items, $this->getArrayableItems( $items ) ) );
     }
 
     /**
@@ -683,9 +683,9 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function intersectKey($items)
+    public function intersectKey( $items )
     {
-        return new static(array_intersect_key($this->items, $this->getArrayableItems($items)));
+        return new static( array_intersect_key( $this->items, $this->getArrayableItems( $items ) ) );
     }
 
     /**
@@ -695,7 +695,7 @@ 
      */
     public function isEmpty()
     {
-        return empty($this->items);
+        return empty( $this->items );
     }
 
     /**
@@ -714,9 +714,9 @@ 
      * @param  mixed  $value
      * @return bool
      */
-    protected function useAsCallable($value)
+    protected function useAsCallable( $value )
     {
-        return ! is_string($value) && is_callable($value);
+        return ! is_string( $value ) && is_callable( $value );
     }
 
     /**
@@ -726,7 +726,7 @@ 
      */
     public function keys()
     {
-        return new static(array_keys($this->items));
+        return new static( array_keys( $this->items ) );
     }
 
     /**
@@ -736,9 +736,9 @@ 
      * @param  mixed  $default
      * @return mixed
      */
-    public function last(callable $callback = null, $default = null)
+    public function last( callable $callback = null, $default = null )
     {
-        return Arr::last($this->items, $callback, $default);
+        return Arr::last( $this->items, $callback, $default );
     }
 
     /**
@@ -748,9 +748,9 @@ 
      * @param  string|null  $key
      * @return static
      */
-    public function pluck($value, $key = null)
+    public function pluck( $value, $key = null )
     {
-        return new static(Arr::pluck($this->items, $value, $key));
+        return new static( Arr::pluck( $this->items, $value, $key ) );
     }
 
     /**
@@ -759,13 +759,13 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public function map(callable $callback)
+    public function map( callable $callback )
     {
-        $keys = array_keys($this->items);
+        $keys = array_keys( $this->items );
 
-        $items = array_map($callback, $this->items, $keys);
+        $items = array_map( $callback, $this->items, $keys );
 
-        return new static(array_combine($keys, $items));
+        return new static( array_combine( $keys, $items ) );
     }
 
     /**
@@ -774,10 +774,10 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public function mapSpread(callable $callback)
+    public function mapSpread( callable $callback )
     {
-        return $this->map(function ($chunk) use ($callback) {
-            return $callback(...$chunk);
+        return $this->map( function( $chunk ) use ( $callback ) {
+            return $callback( ...$chunk );
         });
     }
 
@@ -789,15 +789,15 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public function mapToGroups(callable $callback)
+    public function mapToGroups( callable $callback )
     {
-        $groups = $this->map($callback)->reduce(function ($groups, $pair) {
-            $groups[key($pair)][] = reset($pair);
+        $groups = $this->map( $callback )->reduce( function( $groups, $pair ) {
+            $groups[ key( $pair ) ][ ] = reset( $pair );
 
             return $groups;
-        }, []);
+        }, [ ] );
 
-        return (new static($groups))->map([$this, 'make']);
+        return ( new static( $groups ) )->map( [ $this, 'make' ] );
     }
 
     /**
@@ -808,19 +808,19 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public function mapWithKeys(callable $callback)
+    public function mapWithKeys( callable $callback )
     {
-        $result = [];
+        $result = [ ];
 
-        foreach ($this->items as $key => $value) {
-            $assoc = $callback($value, $key);
+        foreach ( $this->items as $key => $value ) {
+            $assoc = $callback( $value, $key );
 
-            foreach ($assoc as $mapKey => $mapValue) {
-                $result[$mapKey] = $mapValue;
+            foreach ( $assoc as $mapKey => $mapValue ) {
+                $result[ $mapKey ] = $mapValue;
             }
         }
 
-        return new static($result);
+        return new static( $result );
     }
 
     /**
@@ -829,9 +829,9 @@ 
      * @param  callable  $callback
      * @return static
      */
-    public function flatMap(callable $callback)
+    public function flatMap( callable $callback )
     {
-        return $this->map($callback)->collapse();
+        return $this->map( $callback )->collapse();
     }
 
     /**
@@ -840,16 +840,16 @@ 
      * @param  callable|string|null  $callback
      * @return mixed
      */
-    public function max($callback = null)
+    public function max( $callback = null )
     {
-        $callback = $this->valueRetriever($callback);
+        $callback = $this->valueRetriever( $callback );
 
-        return $this->filter(function ($value) {
-            return ! is_null($value);
-        })->reduce(function ($result, $item) use ($callback) {
-            $value = $callback($item);
+        return $this->filter( function( $value ) {
+            return ! is_null( $value );
+        })->reduce( function( $result, $item ) use ( $callback ) {
+            $value = $callback( $item );
 
-            return is_null($result) || $value > $result ? $value : $result;
+            return is_null( $result ) || $value > $result ? $value : $result;
         });
     }
 
@@ -859,9 +859,9 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function merge($items)
+    public function merge( $items )
     {
-        return new static(array_merge($this->items, $this->getArrayableItems($items)));
+        return new static( array_merge( $this->items, $this->getArrayableItems( $items ) ) );
     }
 
     /**
@@ -870,9 +870,9 @@ 
      * @param  mixed  $values
      * @return static
      */
-    public function combine($values)
+    public function combine( $values )
     {
-        return new static(array_combine($this->all(), $this->getArrayableItems($values)));
+        return new static( array_combine( $this->all(), $this->getArrayableItems( $values ) ) );
     }
 
     /**
@@ -881,9 +881,9 @@ 
      * @param  mixed  $items
      * @return static
      */
-    public function union($items)
+    public function union( $items )
     {
-        return new static($this->items + $this->getArrayableItems($items));
+        return new static( $this->items + $this->getArrayableItems( $items ) );
     }
 
     /**
@@ -892,16 +892,16 @@ 
      * @param  callable|string|null  $callback
      * @return mixed
      */
-    public function min($callback = null)
+    public function min( $callback = null )
     {
-        $callback = $this->valueRetriever($callback);
+        $callback = $this->valueRetriever( $callback );
 
-        return $this->filter(function ($value) {
-            return ! is_null($value);
-        })->reduce(function ($result, $item) use ($callback) {
-            $value = $callback($item);
+        return $this->filter( function( $value ) {
+            return ! is_null( $value );
+        })->reduce( function( $result, $item ) use ( $callback ) {
+            $value = $callback( $item );
 
-            return is_null($result) || $value < $result ? $value : $result;
+            return is_null( $result ) || $value < $result ? $value : $result;
         });
     }
 
@@ -912,21 +912,21 @@ 
      * @param  int  $offset
      * @return static
      */
-    public function nth($step, $offset = 0)
+    public function nth( $step, $offset = 0 )
     {
-        $new = [];
+        $new = [ ];
 
         $position = 0;
 
-        foreach ($this->items as $item) {
-            if ($position % $step === $offset) {
-                $new[] = $item;
+        foreach ( $this->items as $item ) {
+            if ( $position % $step === $offset ) {
+                $new[ ] = $item;
             }
 
             $position++;
         }
 
-        return new static($new);
+        return new static( $new );
     }
 
     /**
@@ -935,15 +935,15 @@ 
      * @param  mixed  $keys
      * @return static
      */
-    public function only($keys)
+    public function only( $keys )
     {
-        if (is_null($keys)) {
-            return new static($this->items);
+        if ( is_null( $keys ) ) {
+            return new static( $this->items );
         }
 
-        $keys = is_array($keys) ? $keys : func_get_args();
+        $keys = is_array( $keys ) ? $keys : func_get_args();
 
-        return new static(Arr::only($this->items, $keys));
+        return new static( Arr::only( $this->items, $keys ) );
     }
 
     /**
@@ -953,9 +953,9 @@ 
      * @param  int  $perPage
      * @return static
      */
-    public function forPage($page, $perPage)
+    public function forPage( $page, $perPage )
     {
-        return $this->slice(($page - 1) * $perPage, $perPage);
+        return $this->slice( ( $page - 1 ) * $perPage, $perPage );
     }
 
     /**
@@ -964,17 +964,17 @@ 
      * @param  callable|string  $callback
      * @return static
      */
-    public function partition($callback)
+    public function partition( $callback )
     {
-        $partitions = [new static, new static];
+        $partitions = [ new static, new static ];
 
-        $callback = $this->valueRetriever($callback);
+        $callback = $this->valueRetriever( $callback );
 
-        foreach ($this->items as $key => $item) {
-            $partitions[(int) ! $callback($item)][$key] = $item;
+        foreach ( $this->items as $key => $item ) {
+            $partitions[ (int)! $callback( $item ) ][ $key ] = $item;
         }
 
-        return new static($partitions);
+        return new static( $partitions );
     }
 
     /**
@@ -983,9 +983,9 @@ 
      * @param  callable $callback
      * @return mixed
      */
-    public function pipe(callable $callback)
+    public function pipe( callable $callback )
     {
-        return $callback($this);
+        return $callback( $this );
     }
 
     /**
@@ -995,7 +995,7 @@ 
      */
     public function pop()
     {
-        return array_pop($this->items);
+        return array_pop( $this->items );
     }
 
     /**
@@ -1005,9 +1005,9 @@ 
      * @param  mixed  $key
      * @return $this
      */
-    public function prepend($value, $key = null)
+    public function prepend( $value, $key = null )
     {
-        $this->items = Arr::prepend($this->items, $value, $key);
+        $this->items = Arr::prepend( $this->items, $value, $key );
 
         return $this;
     }
@@ -1018,9 +1018,9 @@ 
      * @param  mixed  $value
      * @return $this
      */
-    public function push($value)
+    public function push( $value )
     {
-        $this->offsetSet(null, $value);
+        $this->offsetSet( null, $value );
 
         return $this;
     }
@@ -1031,12 +1031,12 @@ 
      * @param  \Traversable  $source
      * @return self
      */
-    public function concat($source)
+    public function concat( $source )
     {
-        $result = new static($this);
+        $result = new static( $this );
 
-        foreach ($source as $item) {
-            $result->push($item);
+        foreach ( $source as $item ) {
+            $result->push( $item );
         }
 
         return $result;
@@ -1049,9 +1049,9 @@ 
      * @param  mixed  $default
      * @return mixed
      */
-    public function pull($key, $default = null)
+    public function pull( $key, $default = null )
     {
-        return Arr::pull($this->items, $key, $default);
+        return Arr::pull( $this->items, $key, $default );
     }
 
     /**
@@ -1061,9 +1061,9 @@ 
      * @param  mixed  $value
      * @return $this
      */
-    public function put($key, $value)
+    public function put( $key, $value )
     {
-        $this->offsetSet($key, $value);
+        $this->offsetSet( $key, $value );
 
         return $this;
     }
@@ -1076,13 +1076,13 @@ 
      *
      * @throws \InvalidArgumentException
      */
-    public function random($number = null)
+    public function random( $number = null )
     {
-        if (is_null($number)) {
-            return Arr::random($this->items);
+        if ( is_null( $number ) ) {
+            return Arr::random( $this->items );
         }
 
-        return new static(Arr::random($this->items, $number));
+        return new static( Arr::random( $this->items, $number ) );
     }
 
     /**
@@ -1092,9 +1092,9 @@ 
      * @param  mixed  $initial
      * @return mixed
      */
-    public function reduce(callable $callback, $initial = null)
+    public function reduce( callable $callback, $initial = null )
     {
-        return array_reduce($this->items, $callback, $initial);
+        return array_reduce( $this->items, $callback, $initial );
     }
 
     /**
@@ -1103,15 +1103,15 @@ 
      * @param  callable|mixed  $callback
      * @return static
      */
-    public function reject($callback)
+    public function reject( $callback )
     {
-        if ($this->useAsCallable($callback)) {
-            return $this->filter(function ($value, $key) use ($callback) {
-                return ! $callback($value, $key);
+        if ( $this->useAsCallable( $callback ) ) {
+            return $this->filter( function( $value, $key ) use ( $callback ) {
+                return ! $callback( $value, $key );
             });
         }
 
-        return $this->filter(function ($item) use ($callback) {
+        return $this->filter( function( $item ) use ( $callback ) {
             return $item != $callback;
         });
     }
@@ -1123,7 +1123,7 @@ 
      */
     public function reverse()
     {
-        return new static(array_reverse($this->items, true));
+        return new static( array_reverse( $this->items, true ) );
     }
 
     /**
@@ -1133,14 +1133,14 @@ 
      * @param  bool  $strict
      * @return mixed
      */
-    public function search($value, $strict = false)
+    public function search( $value, $strict = false )
     {
-        if (! $this->useAsCallable($value)) {
-            return array_search($value, $this->items, $strict);
+        if ( ! $this->useAsCallable( $value ) ) {
+            return array_search( $value, $this->items, $strict );
         }
 
-        foreach ($this->items as $key => $item) {
-            if (call_user_func($value, $item, $key)) {
+        foreach ( $this->items as $key => $item ) {
+            if ( call_user_func( $value, $item, $key ) ) {
                 return $key;
             }
         }
@@ -1155,7 +1155,7 @@ 
      */
     public function shift()
     {
-        return array_shift($this->items);
+        return array_shift( $this->items );
     }
 
     /**
@@ -1164,21 +1164,21 @@ 
      * @param  int  $seed
      * @return static
      */
-    public function shuffle($seed = null)
+    public function shuffle( $seed = null )
     {
         $items = $this->items;
 
-        if (is_null($seed)) {
-            shuffle($items);
+        if ( is_null( $seed ) ) {
+            shuffle( $items );
         } else {
-            srand($seed);
+            srand( $seed );
 
-            usort($items, function () {
+            usort( $items, function() {
                 return rand(-1, 1);
             });
         }
 
-        return new static($items);
+        return new static( $items );
     }
 
     /**
@@ -1188,9 +1188,9 @@ 
      * @param  int  $length
      * @return static
      */
-    public function slice($offset, $length = null)
+    public function slice( $offset, $length = null )
     {
-        return new static(array_slice($this->items, $offset, $length, true));
+        return new static( array_slice( $this->items, $offset, $length, true ) );
     }
 
     /**
@@ -1199,15 +1199,15 @@ 
      * @param  int  $numberOfGroups
      * @return static
      */
-    public function split($numberOfGroups)
+    public function split( $numberOfGroups )
     {
-        if ($this->isEmpty()) {
+        if ( $this->isEmpty() ) {
             return new static;
         }
 
-        $groupSize = ceil($this->count() / $numberOfGroups);
+        $groupSize = ceil( $this->count() / $numberOfGroups );
 
-        return $this->chunk($groupSize);
+        return $this->chunk( $groupSize );
     }
 
     /**
@@ -1216,19 +1216,19 @@ 
      * @param  int  $size
      * @return static
      */
-    public function chunk($size)
+    public function chunk( $size )
     {
-        if ($size <= 0) {
+        if ( $size <= 0 ) {
             return new static;
         }
 
-        $chunks = [];
+        $chunks = [ ];
 
-        foreach (array_chunk($this->items, $size, true) as $chunk) {
-            $chunks[] = new static($chunk);
+        foreach ( array_chunk( $this->items, $size, true ) as $chunk ) {
+            $chunks[ ] = new static( $chunk );
         }
 
-        return new static($chunks);
+        return new static( $chunks );
     }
 
     /**
@@ -1237,15 +1237,15 @@ 
      * @param  callable|null  $callback
      * @return static
      */
-    public function sort(callable $callback = null)
+    public function sort( callable $callback = null )
     {
         $items = $this->items;
 
         $callback
-            ? uasort($items, $callback)
-            : asort($items);
+            ? uasort( $items, $callback )
+            : asort( $items );
 
-        return new static($items);
+        return new static( $items );
     }
 
     /**
@@ -1256,30 +1256,30 @@ 
      * @param  bool  $descending
      * @return static
      */
-    public function sortBy($callback, $options = SORT_REGULAR, $descending = false)
+    public function sortBy( $callback, $options = SORT_REGULAR, $descending = false )
     {
-        $results = [];
+        $results = [ ];
 
-        $callback = $this->valueRetriever($callback);
+        $callback = $this->valueRetriever( $callback );
 
         // First we will loop through the items and get the comparator from a callback
         // function which we were given. Then, we will sort the returned values and
         // and grab the corresponding values for the sorted keys from this array.
-        foreach ($this->items as $key => $value) {
-            $results[$key] = $callback($value, $key);
+        foreach ( $this->items as $key => $value ) {
+            $results[ $key ] = $callback( $value, $key );
         }
 
-        $descending ? arsort($results, $options)
-                    : asort($results, $options);
+        $descending ? arsort( $results, $options )
+                    : asort( $results, $options );
 
         // Once we have sorted all of the keys in the array, we will loop through them
         // and grab the corresponding model so we can set the underlying items list
         // to the sorted version. Then we'll just return the collection instance.
-        foreach (array_keys($results) as $key) {
-            $results[$key] = $this->items[$key];
+        foreach ( array_keys( $results ) as $key ) {
+            $results[ $key ] = $this->items[ $key ];
         }
 
-        return new static($results);
+        return new static( $results );
     }
 
     /**
@@ -1289,9 +1289,9 @@ 
      * @param  int  $options
      * @return static
      */
-    public function sortByDesc($callback, $options = SORT_REGULAR)
+    public function sortByDesc( $callback, $options = SORT_REGULAR )
     {
-        return $this->sortBy($callback, $options, true);
+        return $this->sortBy( $callback, $options, true );
     }
 
     /**
@@ -1302,13 +1302,13 @@ 
      * @param  mixed  $replacement
      * @return static
      */
-    public function splice($offset, $length = null, $replacement = [])
+    public function splice( $offset, $length = null, $replacement = [ ] )
     {
-        if (func_num_args() == 1) {
-            return new static(array_splice($this->items, $offset));
+        if ( func_num_args() == 1 ) {
+            return new static( array_splice( $this->items, $offset ) );
         }
 
-        return new static(array_splice($this->items, $offset, $length, $replacement));
+        return new static( array_splice( $this->items, $offset, $length, $replacement ) );
     }
 
     /**
@@ -1317,17 +1317,17 @@ 
      * @param  callable|string|null  $callback
      * @return mixed
      */
-    public function sum($callback = null)
+    public function sum( $callback = null )
     {
-        if (is_null($callback)) {
-            return array_sum($this->items);
+        if ( is_null( $callback ) ) {
+            return array_sum( $this->items );
         }
 
-        $callback = $this->valueRetriever($callback);
+        $callback = $this->valueRetriever( $callback );
 
-        return $this->reduce(function ($result, $item) use ($callback) {
-            return $result + $callback($item);
-        }, 0);
+        return $this->reduce( function( $result, $item ) use ( $callback ) {
+            return $result + $callback( $item );
+        }, 0 );
     }
 
     /**
@@ -1336,13 +1336,13 @@ 
      * @param  int  $limit
      * @return static
      */
-    public function take($limit)
+    public function take( $limit )
     {
-        if ($limit < 0) {
-            return $this->slice($limit, abs($limit));
+        if ( $limit < 0 ) {
+            return $this->slice( $limit, abs( $limit ) );
         }
 
-        return $this->slice(0, $limit);
+        return $this->slice( 0, $limit );
     }
 
     /**
@@ -1351,9 +1351,9 @@ 
      * @param  callable  $callback
      * @return $this
      */
-    public function tap(callable $callback)
+    public function tap( callable $callback )
     {
-        $callback(new static($this->items));
+        $callback( new static( $this->items ) );
 
         return $this;
     }
@@ -1364,9 +1364,9 @@ 
      * @param  callable  $callback
      * @return $this
      */
-    public function transform(callable $callback)
+    public function transform( callable $callback )
     {
-        $this->items = $this->map($callback)->all();
+        $this->items = $this->map( $callback )->all();
 
         return $this;
     }
@@ -1378,22 +1378,22 @@ 
      * @param  bool  $strict
      * @return static
      */
-    public function unique($key = null, $strict = false)
+    public function unique( $key = null, $strict = false )
     {
-        if (is_null($key)) {
-            return new static(array_unique($this->items, SORT_REGULAR));
+        if ( is_null( $key ) ) {
+            return new static( array_unique( $this->items, SORT_REGULAR ) );
         }
 
-        $callback = $this->valueRetriever($key);
+        $callback = $this->valueRetriever( $key );
 
-        $exists = [];
+        $exists = [ ];
 
-        return $this->reject(function ($item, $key) use ($callback, $strict, &$exists) {
-            if (in_array($id = $callback($item, $key), $exists, $strict)) {
+        return $this->reject( function( $item, $key ) use ( $callback, $strict, &$exists ) {
+            if ( in_array( $id = $callback( $item, $key ), $exists, $strict ) ) {
                 return true;
             }
 
-            $exists[] = $id;
+            $exists[ ] = $id;
         });
     }
 
@@ -1403,9 +1403,9 @@ 
      * @param  string|callable|null  $key
      * @return static
      */
-    public function uniqueStrict($key = null)
+    public function uniqueStrict( $key = null )
     {
-        return $this->unique($key, true);
+        return $this->unique( $key, true );
     }
 
     /**
@@ -1415,7 +1415,7 @@ 
      */
     public function values()
     {
-        return new static(array_values($this->items));
+        return new static( array_values( $this->items ) );
     }
 
     /**
@@ -1424,14 +1424,14 @@ 
      * @param  string  $value
      * @return callable
      */
-    protected function valueRetriever($value)
+    protected function valueRetriever( $value )
     {
-        if ($this->useAsCallable($value)) {
+        if ( $this->useAsCallable( $value ) ) {
             return $value;
         }
 
-        return function ($item) use ($value) {
-            return data_get($item, $value);
+        return function( $item ) use ( $value ) {
+            return data_get( $item, $value );
         };
     }
 
@@ -1444,17 +1444,17 @@ 
      * @param  mixed ...$items
      * @return static
      */
-    public function zip($items)
+    public function zip( $items )
     {
-        $arrayableItems = array_map(function ($items) {
-            return $this->getArrayableItems($items);
-        }, func_get_args());
+        $arrayableItems = array_map( function( $items ) {
+            return $this->getArrayableItems( $items );
+        }, func_get_args() );
 
-        $params = array_merge([function () {
-            return new static(func_get_args());
-        }, $this->items], $arrayableItems);
+        $params = array_merge( [ function() {
+            return new static( func_get_args() );
+        }, $this->items ], $arrayableItems );
 
-        return new static(call_user_func_array('array_map', $params));
+        return new static( call_user_func_array( 'array_map', $params ) );
     }
 
     /**
@@ -1464,9 +1464,9 @@ 
      */
     public function toArray()
     {
-        return array_map(function ($value) {
+        return array_map( function( $value ) {
             return $value instanceof Arrayable ? $value->toArray() : $value;
-        }, $this->items);
+        }, $this->items );
     }
 
     /**
@@ -1476,17 +1476,17 @@ 
      */
     public function jsonSerialize()
     {
-        return array_map(function ($value) {
-            if ($value instanceof JsonSerializable) {
+        return array_map( function( $value ) {
+            if ( $value instanceof JsonSerializable ) {
                 return $value->jsonSerialize();
-            } elseif ($value instanceof Jsonable) {
-                return json_decode($value->toJson(), true);
-            } elseif ($value instanceof Arrayable) {
+            } elseif ( $value instanceof Jsonable ) {
+                return json_decode( $value->toJson(), true );
+            } elseif ( $value instanceof Arrayable ) {
                 return $value->toArray();
             } else {
                 return $value;
             }
-        }, $this->items);
+        }, $this->items );
     }
 
     /**
@@ -1495,9 +1495,9 @@ 
      * @param  int  $options
      * @return string
      */
-    public function toJson($options = 0)
+    public function toJson( $options = 0 )
     {
-        return json_encode($this->jsonSerialize(), $options);
+        return json_encode( $this->jsonSerialize(), $options );
     }
 
     /**
@@ -1507,7 +1507,7 @@ 
      */
     public function getIterator()
     {
-        return new ArrayIterator($this->items);
+        return new ArrayIterator( $this->items );
     }
 
     /**
@@ -1516,9 +1516,9 @@ 
      * @param  int  $flags
      * @return \CachingIterator
      */
-    public function getCachingIterator($flags = CachingIterator::CALL_TOSTRING)
+    public function getCachingIterator( $flags = CachingIterator::CALL_TOSTRING )
     {
-        return new CachingIterator($this->getIterator(), $flags);
+        return new CachingIterator( $this->getIterator(), $flags );
     }
 
     /**
@@ -1528,7 +1528,7 @@ 
      */
     public function count()
     {
-        return count($this->items);
+        return count( $this->items );
     }
 
     /**
@@ -1538,7 +1538,7 @@ 
      */
     public function toBase()
     {
-        return new self($this);
+        return new self( $this );
     }
 
     /**
@@ -1547,9 +1547,9 @@ 
      * @param  mixed  $key
      * @return bool
      */
-    public function offsetExists($key)
+    public function offsetExists( $key )
     {
-        return array_key_exists($key, $this->items);
+        return array_key_exists( $key, $this->items );
     }
 
     /**
@@ -1558,9 +1558,9 @@ 
      * @param  mixed  $key
      * @return mixed
      */
-    public function offsetGet($key)
+    public function offsetGet( $key )
     {
-        return $this->items[$key];
+        return $this->items[ $key ];
     }
 
     /**
@@ -1570,12 +1570,12 @@ 
      * @param  mixed  $value
      * @return void
      */
-    public function offsetSet($key, $value)
+    public function offsetSet( $key, $value )
     {
-        if (is_null($key)) {
-            $this->items[] = $value;
+        if ( is_null( $key ) ) {
+            $this->items[ ] = $value;
         } else {
-            $this->items[$key] = $value;
+            $this->items[ $key ] = $value;
         }
     }
 
@@ -1585,9 +1585,9 @@ 
      * @param  string  $key
      * @return void
      */
-    public function offsetUnset($key)
+    public function offsetUnset( $key )
     {
-        unset($this->items[$key]);
+        unset( $this->items[ $key ] );
     }
 
     /**
@@ -1606,23 +1606,23 @@ 
      * @param  mixed  $items
      * @return array
      */
-    protected function getArrayableItems($items)
+    protected function getArrayableItems( $items )
     {
-        if (is_array($items)) {
+        if ( is_array( $items ) ) {
             return $items;
-        } elseif ($items instanceof self) {
+        } elseif ( $items instanceof self ) {
             return $items->all();
-        } elseif ($items instanceof Arrayable) {
+        } elseif ( $items instanceof Arrayable ) {
             return $items->toArray();
-        } elseif ($items instanceof Jsonable) {
-            return json_decode($items->toJson(), true);
-        } elseif ($items instanceof JsonSerializable) {
+        } elseif ( $items instanceof Jsonable ) {
+            return json_decode( $items->toJson(), true );
+        } elseif ( $items instanceof JsonSerializable ) {
             return $items->jsonSerialize();
-        } elseif ($items instanceof Traversable) {
-            return iterator_to_array($items);
+        } elseif ( $items instanceof Traversable ) {
+            return iterator_to_array( $items );
         }
 
-        return (array) $items;
+        return (array)$items;
     }
 
     /**
@@ -1631,9 +1631,9 @@ 
      * @param  string  $method
      * @return void
      */
-    public static function proxy($method)
+    public static function proxy( $method )
     {
-        static::$proxies[] = $method;
+        static::$proxies[ ] = $method;
     }
 
     /**
@@ -1644,12 +1644,12 @@ 
      *
      * @throws \Exception
      */
-    public function __get($key)
+    public function __get( $key )
     {
-        if (! in_array($key, static::$proxies)) {
-            throw new Exception("Property [{$key}] does not exist on this collection instance.");
+        if ( ! in_array( $key, static::$proxies ) ) {
+            throw new Exception( "Property [{$key}] does not exist on this collection instance." );
         }
 
-        return new HigherOrderCollectionProxy($this, $key);
+        return new HigherOrderCollectionProxy( $this, $key );
     }
 }

vendor/illuminate/support/Facades/Input.php

Spacing +2 added lines, -2 removed lines

@@ -16,9 +16,9 @@
      * @param  mixed   $default
      * @return mixed
      */
-    public static function get($key = null, $default = null)
+    public static function get( $key = null, $default = null )
     {
-        return static::$app['request']->input($key, $default);
+        return static::$app[ 'request' ]->input( $key, $default );
     }
 
     /**

vendor/illuminate/support/Arr.php

Spacing +148 added lines, -148 removed lines

@@ -16,9 +16,9 @@ 
      * @param  mixed  $value
      * @return bool
      */
-    public static function accessible($value)
+    public static function accessible( $value )
     {
-        return is_array($value) || $value instanceof ArrayAccess;
+        return is_array( $value ) || $value instanceof ArrayAccess;
     }
 
     /**
@@ -29,10 +29,10 @@ 
      * @param  mixed   $value
      * @return array
      */
-    public static function add($array, $key, $value)
+    public static function add( $array, $key, $value )
     {
-        if (is_null(static::get($array, $key))) {
-            static::set($array, $key, $value);
+        if ( is_null( static::get( $array, $key ) ) ) {
+            static::set( $array, $key, $value );
         }
 
         return $array;
@@ -44,18 +44,18 @@ 
      * @param  array  $array
      * @return array
      */
-    public static function collapse($array)
+    public static function collapse( $array )
     {
-        $results = [];
+        $results = [ ];
 
-        foreach ($array as $values) {
-            if ($values instanceof Collection) {
+        foreach ( $array as $values ) {
+            if ( $values instanceof Collection ) {
                 $values = $values->all();
-            } elseif (! is_array($values)) {
+            } elseif ( ! is_array( $values ) ) {
                 continue;
             }
 
-            $results = array_merge($results, $values);
+            $results = array_merge( $results, $values );
         }
 
         return $results;
@@ -67,18 +67,18 @@ 
      * @param  array  ...$arrays
      * @return array
      */
-    public static function crossJoin(...$arrays)
+    public static function crossJoin( ...$arrays )
     {
-        $results = [[]];
+        $results = [ [ ] ];
 
-        foreach ($arrays as $index => $array) {
-            $append = [];
+        foreach ( $arrays as $index => $array ) {
+            $append = [ ];
 
-            foreach ($results as $product) {
-                foreach ($array as $item) {
-                    $product[$index] = $item;
+            foreach ( $results as $product ) {
+                foreach ( $array as $item ) {
+                    $product[ $index ] = $item;
 
-                    $append[] = $product;
+                    $append[ ] = $product;
                 }
             }
 
@@ -94,9 +94,9 @@ 
      * @param  array  $array
      * @return array
      */
-    public static function divide($array)
+    public static function divide( $array )
     {
-        return [array_keys($array), array_values($array)];
+        return [ array_keys( $array ), array_values( $array ) ];
     }
 
     /**
@@ -106,15 +106,15 @@ 
      * @param  string  $prepend
      * @return array
      */
-    public static function dot($array, $prepend = '')
+    public static function dot( $array, $prepend = '' )
     {
-        $results = [];
+        $results = [ ];
 
-        foreach ($array as $key => $value) {
-            if (is_array($value) && ! empty($value)) {
-                $results = array_merge($results, static::dot($value, $prepend.$key.'.'));
+        foreach ( $array as $key => $value ) {
+            if ( is_array( $value ) && ! empty( $value ) ) {
+                $results = array_merge( $results, static::dot( $value, $prepend . $key . '.' ) );
             } else {
-                $results[$prepend.$key] = $value;
+                $results[ $prepend . $key ] = $value;
             }
         }
 
@@ -128,9 +128,9 @@ 
      * @param  array|string  $keys
      * @return array
      */
-    public static function except($array, $keys)
+    public static function except( $array, $keys )
     {
-        static::forget($array, $keys);
+        static::forget( $array, $keys );
 
         return $array;
     }
@@ -142,13 +142,13 @@ 
      * @param  string|int  $key
      * @return bool
      */
-    public static function exists($array, $key)
+    public static function exists( $array, $key )
     {
-        if ($array instanceof ArrayAccess) {
-            return $array->offsetExists($key);
+        if ( $array instanceof ArrayAccess ) {
+            return $array->offsetExists( $key );
         }
 
-        return array_key_exists($key, $array);
+        return array_key_exists( $key, $array );
     }
 
     /**
@@ -159,25 +159,25 @@ 
      * @param  mixed  $default
      * @return mixed
      */
-    public static function first($array, callable $callback = null, $default = null)
+    public static function first( $array, callable $callback = null, $default = null )
     {
-        if (is_null($callback)) {
-            if (empty($array)) {
-                return value($default);
+        if ( is_null( $callback ) ) {
+            if ( empty( $array ) ) {
+                return value( $default );
             }
 
-            foreach ($array as $item) {
+            foreach ( $array as $item ) {
                 return $item;
             }
         }
 
-        foreach ($array as $key => $value) {
-            if (call_user_func($callback, $value, $key)) {
+        foreach ( $array as $key => $value ) {
+            if ( call_user_func( $callback, $value, $key ) ) {
                 return $value;
             }
         }
 
-        return value($default);
+        return value( $default );
     }
 
     /**
@@ -188,13 +188,13 @@ 
      * @param  mixed  $default
      * @return mixed
      */
-    public static function last($array, callable $callback = null, $default = null)
+    public static function last( $array, callable $callback = null, $default = null )
     {
-        if (is_null($callback)) {
-            return empty($array) ? value($default) : end($array);
+        if ( is_null( $callback ) ) {
+            return empty( $array ) ? value( $default ) : end( $array );
         }
 
-        return static::first(array_reverse($array, true), $callback, $default);
+        return static::first( array_reverse( $array, true ), $callback, $default );
     }
 
     /**
@@ -204,19 +204,19 @@ 
      * @param  int  $depth
      * @return array
      */
-    public static function flatten($array, $depth = INF)
+    public static function flatten( $array, $depth = INF )
     {
-        return array_reduce($array, function ($result, $item) use ($depth) {
+        return array_reduce( $array, function( $result, $item ) use ( $depth ) {
             $item = $item instanceof Collection ? $item->all() : $item;
 
-            if (! is_array($item)) {
-                return array_merge($result, [$item]);
-            } elseif ($depth === 1) {
-                return array_merge($result, array_values($item));
+            if ( ! is_array( $item ) ) {
+                return array_merge( $result, [ $item ] );
+            } elseif ( $depth === 1 ) {
+                return array_merge( $result, array_values( $item ) );
             } else {
-                return array_merge($result, static::flatten($item, $depth - 1));
+                return array_merge( $result, static::flatten( $item, $depth - 1 ) );
             }
-        }, []);
+        }, [ ] );
     }
 
     /**
@@ -226,40 +226,40 @@ 
      * @param  array|string  $keys
      * @return void
      */
-    public static function forget(&$array, $keys)
+    public static function forget( &$array, $keys )
     {
         $original = &$array;
 
-        $keys = (array) $keys;
+        $keys = (array)$keys;
 
-        if (count($keys) === 0) {
+        if ( count( $keys ) === 0 ) {
             return;
         }
 
-        foreach ($keys as $key) {
+        foreach ( $keys as $key ) {
             // if the exact key exists in the top-level, remove it
-            if (static::exists($array, $key)) {
-                unset($array[$key]);
+            if ( static::exists( $array, $key ) ) {
+                unset( $array[ $key ] );
 
                 continue;
             }
 
-            $parts = explode('.', $key);
+            $parts = explode( '.', $key );
 
             // clean up before each pass
             $array = &$original;
 
-            while (count($parts) > 1) {
-                $part = array_shift($parts);
+            while ( count( $parts ) > 1 ) {
+                $part = array_shift( $parts );
 
-                if (isset($array[$part]) && is_array($array[$part])) {
-                    $array = &$array[$part];
+                if ( isset( $array[ $part ] ) && is_array( $array[ $part ] ) ) {
+                    $array = &$array[ $part ];
                 } else {
                     continue 2;
                 }
             }
 
-            unset($array[array_shift($parts)]);
+            unset( $array[ array_shift( $parts ) ] );
         }
     }
 
@@ -271,25 +271,25 @@ 
      * @param  mixed   $default
      * @return mixed
      */
-    public static function get($array, $key, $default = null)
+    public static function get( $array, $key, $default = null )
     {
-        if (! static::accessible($array)) {
-            return value($default);
+        if ( ! static::accessible( $array ) ) {
+            return value( $default );
         }
 
-        if (is_null($key)) {
+        if ( is_null( $key ) ) {
             return $array;
         }
 
-        if (static::exists($array, $key)) {
-            return $array[$key];
+        if ( static::exists( $array, $key ) ) {
+            return $array[ $key ];
         }
 
-        foreach (explode('.', $key) as $segment) {
-            if (static::accessible($array) && static::exists($array, $segment)) {
-                $array = $array[$segment];
+        foreach ( explode( '.', $key ) as $segment ) {
+            if ( static::accessible( $array ) && static::exists( $array, $segment ) ) {
+                $array = $array[ $segment ];
             } else {
-                return value($default);
+                return value( $default );
             }
         }
 
@@ -303,32 +303,32 @@ 
      * @param  string|array  $keys
      * @return bool
      */
-    public static function has($array, $keys)
+    public static function has( $array, $keys )
     {
-        if (is_null($keys)) {
+        if ( is_null( $keys ) ) {
             return false;
         }
 
-        $keys = (array) $keys;
+        $keys = (array)$keys;
 
-        if (! $array) {
+        if ( ! $array ) {
             return false;
         }
 
-        if ($keys === []) {
+        if ( $keys === [ ] ) {
             return false;
         }
 
-        foreach ($keys as $key) {
+        foreach ( $keys as $key ) {
             $subKeyArray = $array;
 
-            if (static::exists($array, $key)) {
+            if ( static::exists( $array, $key ) ) {
                 continue;
             }
 
-            foreach (explode('.', $key) as $segment) {
-                if (static::accessible($subKeyArray) && static::exists($subKeyArray, $segment)) {
-                    $subKeyArray = $subKeyArray[$segment];
+            foreach ( explode( '.', $key ) as $segment ) {
+                if ( static::accessible( $subKeyArray ) && static::exists( $subKeyArray, $segment ) ) {
+                    $subKeyArray = $subKeyArray[ $segment ];
                 } else {
                     return false;
                 }
@@ -346,11 +346,11 @@ 
      * @param  array  $array
      * @return bool
      */
-    public static function isAssoc(array $array)
+    public static function isAssoc( array $array )
     {
-        $keys = array_keys($array);
+        $keys = array_keys( $array );
 
-        return array_keys($keys) !== $keys;
+        return array_keys( $keys ) !== $keys;
     }
 
     /**
@@ -360,9 +360,9 @@ 
      * @param  array|string  $keys
      * @return array
      */
-    public static function only($array, $keys)
+    public static function only( $array, $keys )
     {
-        return array_intersect_key($array, array_flip((array) $keys));
+        return array_intersect_key( $array, array_flip( (array)$keys ) );
     }
 
     /**
@@ -373,28 +373,28 @@ 
      * @param  string|array|null  $key
      * @return array
      */
-    public static function pluck($array, $value, $key = null)
+    public static function pluck( $array, $value, $key = null )
     {
-        $results = [];
+        $results = [ ];
 
-        list($value, $key) = static::explodePluckParameters($value, $key);
+        list( $value, $key ) = static::explodePluckParameters( $value, $key );
 
-        foreach ($array as $item) {
-            $itemValue = data_get($item, $value);
+        foreach ( $array as $item ) {
+            $itemValue = data_get( $item, $value );
 
             // If the key is "null", we will just append the value to the array and keep
             // looping. Otherwise we will key the array using the value of the key we
             // received from the developer. Then we'll return the final array form.
-            if (is_null($key)) {
-                $results[] = $itemValue;
+            if ( is_null( $key ) ) {
+                $results[ ] = $itemValue;
             } else {
-                $itemKey = data_get($item, $key);
+                $itemKey = data_get( $item, $key );
 
-                if (is_object($itemKey) && method_exists($itemKey, '__toString')) {
-                    $itemKey = (string) $itemKey;
+                if ( is_object( $itemKey ) && method_exists( $itemKey, '__toString' ) ) {
+                    $itemKey = (string)$itemKey;
                 }
 
-                $results[$itemKey] = $itemValue;
+                $results[ $itemKey ] = $itemValue;
             }
         }
 
@@ -408,13 +408,13 @@ 
      * @param  string|array|null  $key
      * @return array
      */
-    protected static function explodePluckParameters($value, $key)
+    protected static function explodePluckParameters( $value, $key )
     {
-        $value = is_string($value) ? explode('.', $value) : $value;
+        $value = is_string( $value ) ? explode( '.', $value ) : $value;
 
-        $key = is_null($key) || is_array($key) ? $key : explode('.', $key);
+        $key = is_null( $key ) || is_array( $key ) ? $key : explode( '.', $key );
 
-        return [$value, $key];
+        return [ $value, $key ];
     }
 
     /**
@@ -425,12 +425,12 @@ 
      * @param  mixed  $key
      * @return array
      */
-    public static function prepend($array, $value, $key = null)
+    public static function prepend( $array, $value, $key = null )
     {
-        if (is_null($key)) {
-            array_unshift($array, $value);
+        if ( is_null( $key ) ) {
+            array_unshift( $array, $value );
         } else {
-            $array = [$key => $value] + $array;
+            $array = [ $key => $value ] + $array;
         }
 
         return $array;
@@ -444,11 +444,11 @@ 
      * @param  mixed   $default
      * @return mixed
      */
-    public static function pull(&$array, $key, $default = null)
+    public static function pull( &$array, $key, $default = null )
     {
-        $value = static::get($array, $key, $default);
+        $value = static::get( $array, $key, $default );
 
-        static::forget($array, $key);
+        static::forget( $array, $key );
 
         return $value;
     }
@@ -462,32 +462,32 @@ 
      *
      * @throws \InvalidArgumentException
      */
-    public static function random($array, $number = null)
+    public static function random( $array, $number = null )
     {
-        $requested = is_null($number) ? 1 : $number;
+        $requested = is_null( $number ) ? 1 : $number;
 
-        $count = count($array);
+        $count = count( $array );
 
-        if ($requested > $count) {
+        if ( $requested > $count ) {
             throw new InvalidArgumentException(
                 "You requested {$requested} items, but there are only {$count} items available."
             );
         }
 
-        if (is_null($number)) {
-            return $array[array_rand($array)];
+        if ( is_null( $number ) ) {
+            return $array[ array_rand( $array ) ];
         }
 
-        if ((int) $number === 0) {
-            return [];
+        if ( (int)$number === 0 ) {
+            return [ ];
         }
 
-        $keys = array_rand($array, $number);
+        $keys = array_rand( $array, $number );
 
-        $results = [];
+        $results = [ ];
 
-        foreach ((array) $keys as $key) {
-            $results[] = $array[$key];
+        foreach ( (array)$keys as $key ) {
+            $results[ ] = $array[ $key ];
         }
 
         return $results;
@@ -503,28 +503,28 @@ 
      * @param  mixed   $value
      * @return array
      */
-    public static function set(&$array, $key, $value)
+    public static function set( &$array, $key, $value )
     {
-        if (is_null($key)) {
+        if ( is_null( $key ) ) {
             return $array = $value;
         }
 
-        $keys = explode('.', $key);
+        $keys = explode( '.', $key );
 
-        while (count($keys) > 1) {
-            $key = array_shift($keys);
+        while ( count( $keys ) > 1 ) {
+            $key = array_shift( $keys );
 
             // If the key doesn't exist at this depth, we will just create an empty array
             // to hold the next value, allowing us to create the arrays to hold final
             // values at the correct depth. Then we'll keep digging into the array.
-            if (! isset($array[$key]) || ! is_array($array[$key])) {
-                $array[$key] = [];
+            if ( ! isset( $array[ $key ] ) || ! is_array( $array[ $key ] ) ) {
+                $array[ $key ] = [ ];
             }
 
-            $array = &$array[$key];
+            $array = &$array[ $key ];
         }
 
-        $array[array_shift($keys)] = $value;
+        $array[ array_shift( $keys ) ] = $value;
 
         return $array;
     }
@@ -535,9 +535,9 @@ 
      * @param  array  $array
      * @return array
      */
-    public static function shuffle($array)
+    public static function shuffle( $array )
     {
-        shuffle($array);
+        shuffle( $array );
 
         return $array;
     }
@@ -549,9 +549,9 @@ 
      * @param  callable|string  $callback
      * @return array
      */
-    public static function sort($array, $callback)
+    public static function sort( $array, $callback )
     {
-        return Collection::make($array)->sortBy($callback)->all();
+        return Collection::make( $array )->sortBy( $callback )->all();
     }
 
     /**
@@ -560,18 +560,18 @@ 
      * @param  array  $array
      * @return array
      */
-    public static function sortRecursive($array)
+    public static function sortRecursive( $array )
     {
-        foreach ($array as &$value) {
-            if (is_array($value)) {
-                $value = static::sortRecursive($value);
+        foreach ( $array as &$value ) {
+            if ( is_array( $value ) ) {
+                $value = static::sortRecursive( $value );
             }
         }
 
-        if (static::isAssoc($array)) {
-            ksort($array);
+        if ( static::isAssoc( $array ) ) {
+            ksort( $array );
         } else {
-            sort($array);
+            sort( $array );
         }
 
         return $array;
@@ -584,9 +584,9 @@ 
      * @param  callable  $callback
      * @return array
      */
-    public static function where($array, callable $callback)
+    public static function where( $array, callable $callback )
     {
-        return array_filter($array, $callback, ARRAY_FILTER_USE_BOTH);
+        return array_filter( $array, $callback, ARRAY_FILTER_USE_BOTH );
     }
 
     /**
@@ -595,8 +595,8 @@ 
      * @param  mixed  $value
      * @return array
      */
-    public static function wrap($value)
+    public static function wrap( $value )
     {
-        return ! is_array($value) ? [$value] : $value;
+        return ! is_array( $value ) ? [ $value ] : $value;
     }
 }

vendor/illuminate/support/Debug/Dumper.php

Spacing +4 added lines, -4 removed lines

@@ -13,14 +13,14 @@
      * @param  mixed  $value
      * @return void
      */
-    public function dump($value)
+    public function dump( $value )
     {
-        if (class_exists(CliDumper::class)) {
+        if ( class_exists( CliDumper::class ) ) {
             $dumper = 'cli' === PHP_SAPI ? new CliDumper : new HtmlDumper;
 
-            $dumper->dump((new VarCloner)->cloneVar($value));
+            $dumper->dump( ( new VarCloner )->cloneVar( $value ) );
         } else {
-            var_dump($value);
+            var_dump( $value );
         }
     }
 }

vendor/illuminate/contracts/Logging/Log.php

Spacing +10 added lines, -10 removed lines

@@ -11,7 +11,7 @@ 
      * @param  array  $context
      * @return void
      */
-    public function alert($message, array $context = []);
+    public function alert( $message, array $context = [ ] );
 
     /**
      * Log a critical message to the logs.
@@ -20,7 +20,7 @@ 
      * @param  array  $context
      * @return void
      */
-    public function critical($message, array $context = []);
+    public function critical( $message, array $context = [ ] );
 
     /**
      * Log an error message to the logs.
@@ -29,7 +29,7 @@ 
      * @param  array  $context
      * @return void
      */
-    public function error($message, array $context = []);
+    public function error( $message, array $context = [ ] );
 
     /**
      * Log a warning message to the logs.
@@ -38,7 +38,7 @@ 
      * @param  array  $context
      * @return void
      */
-    public function warning($message, array $context = []);
+    public function warning( $message, array $context = [ ] );
 
     /**
      * Log a notice to the logs.
@@ -47,7 +47,7 @@ 
      * @param  array  $context
      * @return void
      */
-    public function notice($message, array $context = []);
+    public function notice( $message, array $context = [ ] );
 
     /**
      * Log an informational message to the logs.
@@ -56,7 +56,7 @@ 
      * @param  array  $context
      * @return void
      */
-    public function info($message, array $context = []);
+    public function info( $message, array $context = [ ] );
 
     /**
      * Log a debug message to the logs.
@@ -65,7 +65,7 @@ 
      * @param  array  $context
      * @return void
      */
-    public function debug($message, array $context = []);
+    public function debug( $message, array $context = [ ] );
 
     /**
      * Log a message to the logs.
@@ -75,7 +75,7 @@ 
      * @param  array  $context
      * @return void
      */
-    public function log($level, $message, array $context = []);
+    public function log( $level, $message, array $context = [ ] );
 
     /**
      * Register a file log handler.
@@ -84,7 +84,7 @@ 
      * @param  string  $level
      * @return void
      */
-    public function useFiles($path, $level = 'debug');
+    public function useFiles( $path, $level = 'debug' );
 
     /**
      * Register a daily file log handler.
@@ -94,5 +94,5 @@ 
      * @param  string  $level
      * @return void
      */
-    public function useDailyFiles($path, $days = 0, $level = 'debug');
+    public function useDailyFiles( $path, $days = 0, $level = 'debug' );
 }