FramyFramework / Framy

routes/web.php

Spacing +1 added lines, -1 removed lines

@@ -11,7 +11,7 @@
 use app\framework\Component\Routing\Router;
 
 Router::get("/", function() {
-    view("welcome", ["version" => version()]);
+    view("welcome", [ "version" => version() ]);
 });
 
 Router::get("/home", function() {

app/framework/Component/Auth/SessionGuard.php

Spacing +16 added lines, -16 removed lines

@@ -21,7 +21,7 @@ 
 
 class SessionGuard
 {
-    use SingletonTrait,EventManagerTrait;
+    use SingletonTrait, EventManagerTrait;
 
     /**
      * The currently authenticated user.
@@ -78,7 +78,7 @@ 
      */
     public function check()
     {
-        return ! is_null($this->user());
+        return !is_null($this->user());
     }
 
     /**
@@ -89,7 +89,7 @@ 
      */
     public function guest()
     {
-        return ! $this->check();
+        return !$this->check();
     }
 
     /**
@@ -132,7 +132,7 @@ 
         // If we've already retrieved the user for the current request we can just
         // return it back immediately. We do not want to fetch the user data on
         // every call to this method because that would be tremendously slow.
-        if (! is_null($this->user)) {
+        if (!is_null($this->user)) {
             return $this->user;
         }
 
@@ -143,7 +143,7 @@ 
         // request, and if one exists, attempt to retrieve the user using that.
         $user = null;
 
-        if (! is_null($id)) {
+        if (!is_null($id)) {
             $user = $this->provider->retrieveById($id);
         }
 
@@ -152,7 +152,7 @@ 
         // the application. Once we have a user we can return it to the caller.
         $recaller = $this->getRecaller();
 
-        if (is_null($user) && ! is_null($recaller)) {
+        if (is_null($user) && !is_null($recaller)) {
             $user = $this->getUserByRecaller($recaller);
 
             if ($user) {
@@ -174,7 +174,7 @@ 
      * @return bool
      * @throws StringObjectException
      */
-    public function attempt(array $credentials = [], bool $remember = false, $login = true): bool
+    public function attempt(array $credentials = [ ], bool $remember = false, $login = true): bool
     {
         $this->fireAttemptingEvent($credentials, $remember, $login);
 
@@ -196,7 +196,7 @@ 
      */
     protected function createRememberTokenIfDoesntExist()
     {
-        if (! isset($this->user->remember_token)) {
+        if (!isset($this->user->remember_token)) {
             $this->refreshRememberToken();
         }
     }
@@ -210,7 +210,7 @@ 
     {
         $this->session->remove($this->getName());
 
-        if (! is_null($this->getRecaller())) {
+        if (!is_null($this->getRecaller())) {
             $recaller = $this->getRecallerName();
 
             setcookie($recaller, null, -1, '/');
@@ -262,7 +262,7 @@ 
         // listening for anytime a user signs out of this application manually.
         $this->clearUserDataFromStorage();
 
-        if (! is_null($this->user)) {
+        if (!is_null($this->user)) {
             $this->refreshRememberToken();
         }
 
@@ -282,7 +282,7 @@ 
      * @param bool $login
      * @throws StringObjectException
      */
-    protected function fireAttemptingEvent(array $credentials = [], bool $remember = false, $login = true)
+    protected function fireAttemptingEvent(array $credentials = [ ], bool $remember = false, $login = true)
     {
         $this->eventManager()->fire("auth.attempting", [
             'credentials' => $credentials,
@@ -311,12 +311,12 @@ 
      */
     public function getUserByRecaller($recaller)
     {
-        if ($this->validRecaller($recaller) && ! $this->tokenRetrievalAttempted) {
+        if ($this->validRecaller($recaller) && !$this->tokenRetrievalAttempted) {
             $this->tokenRetrievalAttempted = true;
 
             list($id, $token) = explode('|', $recaller, 2);
 
-            $this->viaRemember = ! is_null($user = $this->provider->retrieveByToken($id, $token));
+            $this->viaRemember = !is_null($user = $this->provider->retrieveByToken($id, $token));
 
             return $user;
         }
@@ -361,7 +361,7 @@ 
      */
     protected function hasValidCredentials($user, $credentials)
     {
-        return !is_null($user) && Hash::check($credentials['password'], $user->password);
+        return !is_null($user) && Hash::check($credentials[ 'password' ], $user->password);
     }
 
     /**
@@ -373,12 +373,12 @@ 
      */
     protected function validRecaller($recaller)
     {
-        if (! is_string($recaller) || ! (new StringObject($recaller))->contains('|')) {
+        if (!is_string($recaller) || !(new StringObject($recaller))->contains('|')) {
             return false;
         }
 
         $segments = explode('|', $recaller);
 
-        return count($segments) == 2 && trim($segments[0]) !== '' && trim($segments[1]) !== '';
+        return count($segments) == 2 && trim($segments[ 0 ]) !== '' && trim($segments[ 1 ]) !== '';
     }
 }

app/framework/Component/Auth/AuthenticatesUsers.php

Spacing +8 added lines, -8 removed lines

@@ -46,9 +46,9 @@ 
      * @param array $oldValues
      * @return mixed
      */
-    public function showLoginForm($errors = null, array $oldValues = [])
+    public function showLoginForm($errors = null, array $oldValues = [ ])
     {
-        return view("auth/login", ["errors" => $errors, 'old' => $oldValues]);
+        return view("auth/login", [ "errors" => $errors, 'old' => $oldValues ]);
     }
 
     /**
@@ -66,7 +66,7 @@ 
     public function getPasswordReset()
     {
         // check if user is authenticated redirect to login if not
-        if(! Auth::check()) {
+        if (!Auth::check()) {
             header("Location: /login");
             exit;
         }
@@ -95,8 +95,8 @@ 
         // gets passed from register flow. So we need to
         // remove it to successfully login. I dont understand
         // why but that is how we do it
-        unset($credentials['name']);
-        unset($credentials['remember']);
+        unset($credentials[ 'name' ]);
+        unset($credentials[ 'remember' ]);
 
         $remember = $request->param("remember") ?: false;
 
@@ -143,12 +143,12 @@ 
 
         if ($request->method() === 'GET') {
             // show reset password view
-            return view("auth/passwords/reset", ['token' => $token]);
+            return view("auth/passwords/reset", [ 'token' => $token ]);
         }
 
         $passwordConfirmation = $request->paramsPost()->get("password_confirmation");
         $password             = $request->paramsPost()->get("password");
-        $errors               = arr([]);
+        $errors               = arr([ ]);
 
         if ($password !== $passwordConfirmation) {
             $errors->append("password_confirmation", "Passwords do not match");
@@ -164,7 +164,7 @@ 
         $errors->removeIfValue(true);
 
         if ($errors->count() > 0) {
-            return view("auth/passwords/reset", ["errors" => $errors]);
+            return view("auth/passwords/reset", [ "errors" => $errors ]);
         }
 
         // now everything is fine and the password can be set

app/framework/Component/Auth/UserProvider.php

Spacing +3 added lines, -3 removed lines

@@ -76,16 +76,16 @@
                 handle($e);
             }
 
-            if (! $key->contains("password")) {
+            if (!$key->contains("password")) {
                 $prepend = (0 < $i ? ", " : "");
 
-                $query  .= $prepend. $key ."='". $value."'";
+                $query  .= $prepend.$key."='".$value."'";
 
                 $i++;
             }
         }
 
-        return DB::select($query)[0];
+        return DB::select($query)[ 0 ];
     }
 
     /**

app/framework/Component/Database/Commands/MakeMigration.php

Spacing +1 added lines, -1 removed lines

@@ -72,7 +72,7 @@
         try {
             $File = new File($newMigrationName.".php", new Storage("migrations"), true);
 
-            if(fopen($File->getAbsolutePath(), "w")) {
+            if (fopen($File->getAbsolutePath(), "w")) {
                 $tempDefaultCommand = str_replace("§NAME§", $newMigrationName, $this->template);
                 $tempDefaultCommand = str_replace("§connection§", $connection, $tempDefaultCommand);
                 file_put_contents($File->getAbsolutePath(), $tempDefaultCommand);

app/framework/Component/Database/Query/Grammars/Grammar.php

Spacing +52 added lines, -52 removed lines

@@ -54,7 +54,7 @@ 
         $original = $query->columns;
 
         if (is_null($query->columns)) {
-            $query->columns = ['*'];
+            $query->columns = [ '*' ];
         }
 
         // To compile the query, we'll spin through each component of the query and
@@ -95,8 +95,8 @@ 
         // basic routine regardless of an amount of records given to us to insert.
         $table = $this->wrapTable($query->from);
 
-        if (! is_array(reset($values))) {
-            $values = [$values];
+        if (!is_array(reset($values))) {
+            $values = [ $values ];
         }
 
         $columns = $this->columnize(array_keys(reset($values)));
@@ -104,10 +104,10 @@ 
         // We need to build a list of parameter place-holders of values that are bound
         // to the query. Each insert should have the exact same amount of parameter
         // bindings so we will loop through the record and parameterize them all.
-        $parameters = [];
+        $parameters = [ ];
 
         foreach ($values as $record) {
-            $parameters[] = '('.$this->parameterize($record).')';
+            $parameters[ ] = '('.$this->parameterize($record).')';
         }
 
         $parameters = implode(', ', $parameters);
@@ -124,18 +124,18 @@ 
      */
     public function compileUpdate(Builder $query, array $values): string
     {
-        $table      = $this->wrapTable($query->from);
+        $table = $this->wrapTable($query->from);
 
         // Each one of the columns in the update statements needs to be wrapped in the
         // keyword identifiers, also a place-holder needs to be created for each of
         // the values in the list of bindings so we can make the sets statements.
-        $columns = [];
+        $columns = [ ];
 
         foreach ($values as $key => $value) {
             $param = $this->parameter($value);
             $param = is_string($param) ? "'".$param."'" : $param;
 
-            $columns[] = $this->wrap($key)." = ".$param;
+            $columns[ ] = $this->wrap($key)." = ".$param;
         }
 
         $columns = implode(', ', $columns);
@@ -171,7 +171,7 @@ 
      */
     public function compileTruncate(Builder $query)
     {
-        return ['truncate '.$this->wrapTable($query->from) => []];
+        return [ 'truncate '.$this->wrapTable($query->from) => [ ] ];
     }
 
     /**
@@ -182,16 +182,16 @@ 
      */
     protected function compileComponents(Builder $query)
     {
-        $sql = [];
+        $sql = [ ];
 
         foreach ($this->selectComponents as $component) {
             // To compile the query, we'll spin through each component of the query and
             // see if that component exists. If it does we'll just call the compiler
             // function for the component which is responsible for making the SQL.
             if (!is_null($query->$component)) {
-                $method = 'compile' . ucfirst($component);
+                $method = 'compile'.ucfirst($component);
 
-                $sql[$component] = $this->$method($query, $query->$component);
+                $sql[ $component ] = $this->$method($query, $query->$component);
             }
         }
 
@@ -216,7 +216,7 @@ 
 
         $select = $query->distinct ? 'select distinct ' : 'select ';
 
-        return $select . $this->columnize($columns);
+        return $select.$this->columnize($columns);
     }
 
     /**
@@ -228,7 +228,7 @@ 
      */
     protected function compileFrom(Builder $query, $table)
     {
-        return 'from ' . $this->wrapTable($table);
+        return 'from '.$this->wrapTable($table);
     }
 
     /**
@@ -239,7 +239,7 @@ 
      */
     protected function compileWheres(Builder $query)
     {
-        $sql = [];
+        $sql = [ ];
 
         if (is_null($query->wheres)) {
             return '';
@@ -249,9 +249,9 @@ 
         // for actually creating the where clauses SQL. This helps keep the code nice
         // and maintainable since each clause has a very small method that it uses.
         foreach ($query->wheres as $where) {
-            $method = "where{$where['type']}";
+            $method = "where{$where[ 'type' ]}";
 
-            $sql[] = $where['boolean'].' '.$this->$method($query, $where);
+            $sql[ ] = $where[ 'boolean' ].' '.$this->$method($query, $where);
         }
 
         // If we actually have some where clauses, we will strip off the first boolean
@@ -275,7 +275,7 @@ 
      */
     protected function compileOrders(Builder $query, $orders)
     {
-        return 'order by '.implode(', ', $orders[0])." ".$orders[1];
+        return 'order by '.implode(', ', $orders[ 0 ])." ".$orders[ 1 ];
     }
 
     /**
@@ -299,7 +299,7 @@ 
      */
     protected function compileAggregate(Builder $query, $aggregate)
     {
-        $column = $this->columnize($aggregate['columns']);
+        $column = $this->columnize($aggregate[ 'columns' ]);
 
         // If the query has a "distinct" constraint and we're not asking for all columns
         // we need to prepend "distinct" onto the column name so that the query takes
@@ -308,7 +308,7 @@ 
             $column = 'distinct '.$column;
         }
 
-        return 'select '.$aggregate['function'].'('.$column.') as aggregate';
+        return 'select '.$aggregate[ 'function' ].'('.$column.') as aggregate';
     }
 
     /**
@@ -338,9 +338,9 @@ 
      */
     protected function whereBasic(Builder $query, $where)
     {
-        $value = $this->parameter($where['value']);
+        $value = $this->parameter($where[ 'value' ]);
 
-        return $this->wrap($where['column']).' '.$where['operator'].' '.$value;
+        return $this->wrap($where[ 'column' ]).' '.$where[ 'operator' ].' '.$value;
     }
 
     /**
@@ -352,9 +352,9 @@ 
      */
     protected function whereBetween(Builder $query, $where)
     {
-        $between = $where['not'] ? 'not between' : 'between';
+        $between = $where[ 'not' ] ? 'not between' : 'between';
 
-        return $this->wrap($where['column']).' '.$between.' ? and ?';
+        return $this->wrap($where[ 'column' ]).' '.$between.' ? and ?';
     }
 
     /**
@@ -366,18 +366,18 @@ 
      */
     protected function whereIn(Builder $query, $where)
     {
-        $in = $where['not'] ? 'not in' : 'in';
+        $in = $where[ 'not' ] ? 'not in' : 'in';
 
         $values = " (";
 
         $count = count($query->getBindings());
         for ($i = 1; $i <= $count; $i++) {
-            $append = ($count >  $i) ? "," : "";
-            $values .= "?" . $append;
+            $append = ($count > $i) ? "," : "";
+            $values .= "?".$append;
         }
         $values .= ")";
 
-        return $this->wrap($where['column']). ' '.$in.$values;
+        return $this->wrap($where[ 'column' ]).' '.$in.$values;
     }
 
     /**
@@ -389,9 +389,9 @@ 
      */
     protected function whereNull(Builder $query, $where)
     {
-        $null = $where['not'] ? 'is not null' : 'is null';
+        $null = $where[ 'not' ] ? 'is not null' : 'is null';
 
-        return $this->wrap($where['column']). ' '.$null;
+        return $this->wrap($where[ 'column' ]).' '.$null;
     }
 
     /**
@@ -403,7 +403,7 @@ 
      */
     protected function whereDate(Builder $builder, $where)
     {
-        return $this->wrap($where['column']).$where['operator'].$where['value'];
+        return $this->wrap($where[ 'column' ]).$where[ 'operator' ].$where[ 'value' ];
     }
 
     /**
@@ -415,7 +415,7 @@ 
      */
     protected function whereYear(Builder $builder, $where)
     {
-        return "year(".$this->wrap($where['column']).")".$where['operator'].$where['value'];
+        return "year(".$this->wrap($where[ 'column' ]).")".$where[ 'operator' ].$where[ 'value' ];
     }
 
     /**
@@ -427,7 +427,7 @@ 
      */
     protected function whereMonth(Builder $builder, $where)
     {
-        return "month(".$this->wrap($where['column']).")".$where['operator'].$where['value'];
+        return "month(".$this->wrap($where[ 'column' ]).")".$where[ 'operator' ].$where[ 'value' ];
     }
 
     /**
@@ -439,7 +439,7 @@ 
      */
     protected function whereDay(Builder $builder, $where)
     {
-        return "day(".$this->wrap($where['column']).")".$where['operator'].$where['value'];
+        return "day(".$this->wrap($where[ 'column' ]).")".$where[ 'operator' ].$where[ 'value' ];
     }
 
     /**
@@ -450,8 +450,8 @@ 
      */
     protected function concatenate($segments)
     {
-        return implode(' ', array_filter($segments, function ($value) {
-            return (string)$value !== '';
+        return implode(' ', array_filter($segments, function($value) {
+            return (string) $value !== '';
         }));
     }
 
@@ -463,7 +463,7 @@ 
      */
     public function columnize(array $columns)
     {
-        return implode(', ', array_map([$this, 'wrap'], $columns));
+        return implode(', ', array_map([ $this, 'wrap' ], $columns));
     }
 
     /**
@@ -474,10 +474,10 @@ 
      */
     public function parameterize(array $values)
     {
-        $val = array_map([$this, 'parameter'], $values);
+        $val = array_map([ $this, 'parameter' ], $values);
 
         foreach ($val as $key => $item) {
-            $val[$key] = $this->quoteString($item);
+            $val[ $key ] = $this->quoteString($item);
         }
 
         return implode(', ', $val);
@@ -485,11 +485,11 @@ 
 
     public function parameterizeForUpdate(array $columns, array $values)
     {
-        $queryValues = [];
+        $queryValues = [ ];
 
         $count = count($values);
         for ($i = 0; $i < $count; $i++) {
-            $queryValues[] = $columns[$i]."=".$this->quoteString(array_values($values)[$i]);
+            $queryValues[ ] = $columns[ $i ]."=".$this->quoteString(array_values($values)[ $i ]);
         }
 
         return implode(", ", $queryValues);
@@ -515,7 +515,7 @@ 
     public function quoteString($value)
     {
         if (is_array($value)) {
-            return implode(', ', array_map([$this, __FUNCTION__], $value));
+            return implode(', ', array_map([ $this, __FUNCTION__ ], $value));
         }
 
         return "'$value'";
@@ -530,7 +530,7 @@ 
     public function wrapTable($table)
     {
         if (!$this->isExpression($table)) {
-            return $this->wrap($this->tablePrefix . $table, true);
+            return $this->wrap($this->tablePrefix.$table, true);
         }
 
         return $this->getValue($table);
@@ -556,13 +556,13 @@ 
             $segments = explode(' ', $value);
 
             if ($prefixAlias) {
-                $segments[2] = $this->tablePrefix.$segments[2];
+                $segments[ 2 ] = $this->tablePrefix.$segments[ 2 ];
             }
 
-            return $this->wrap($segments[0]).' as '.$this->wrapValue($segments[2]);
+            return $this->wrap($segments[ 0 ]).' as '.$this->wrapValue($segments[ 2 ]);
         }
 
-        $wrapped = [];
+        $wrapped = [ ];
 
         $segments = explode('.', $value);
 
@@ -571,9 +571,9 @@ 
         // segments as if it was a table and the rest as just regular values.
         foreach ($segments as $key => $segment) {
             if ($key == 0 && count($segments) > 1) {
-                $wrapped[] = $this->wrapTable($segment);
+                $wrapped[ ] = $this->wrapTable($segment);
             } else {
-                $wrapped[] = $this->wrapValue($segment);
+                $wrapped[ ] = $this->wrapValue($segment);
             }
         }
 
@@ -595,11 +595,11 @@ 
         // as well in order to generate proper syntax. If this is a column of course
         // no prefix is necessary. The condition will be true when from wrapTable.
         if ($prefixAlias) {
-            $segments[1] = $this->tablePrefix . $segments[1];
+            $segments[ 1 ] = $this->tablePrefix.$segments[ 1 ];
         }
 
         return $this->wrap(
-                $segments[0]) . ' as ' . $this->wrapValue($segments[1]
+                $segments[ 0 ]).' as '.$this->wrapValue($segments[ 1 ]
             );
     }
 
@@ -611,7 +611,7 @@ 
      */
     protected function wrapSegments($segments)
     {
-        return arr($segments)->map(function ($segment, $key) use ($segments) {
+        return arr($segments)->map(function($segment, $key) use ($segments) {
             return $key == 0 && count($segments) > 1
                 ? $this->wrapTable($segment)
                 : $this->wrapValue($segment);
@@ -627,7 +627,7 @@ 
     protected function wrapValue($value)
     {
         if ($value !== '*') {
-            return '`' . str_replace('"', '""', $value) . '`';
+            return '`'.str_replace('"', '""', $value).'`';
         }
 
         return $value;

app/framework/Component/Database/Query/Builder.php

Spacing +62 added lines, -62 removed lines

@@ -49,12 +49,12 @@ 
      * @var array
      */
     protected $bindings = [
-        'select' => [],
-        'join'   => [],
-        'where'  => [],
-        'having' => [],
-        'order'  => [],
-        'union'  => [],
+        'select' => [ ],
+        'join'   => [ ],
+        'where'  => [ ],
+        'having' => [ ],
+        'order'  => [ ],
+        'union'  => [ ],
     ];
 
     /**
@@ -141,12 +141,12 @@ 
      */
     protected function addArrayOfWheres($column, string $boolean)
     {
-        return $this->whereNested(function ($query) use ($column) {
+        return $this->whereNested(function($query) use ($column) {
 
             /** @var Builder $query */
             foreach ($column as $key => $value) {
                 if (is_numeric($key) && is_array($value)) {
-                    call_user_func_array([$query, 'where'], $value);
+                    call_user_func_array([ $query, 'where' ], $value);
                 } else {
                     $query->where($key, '=', $value);
                 }
@@ -205,14 +205,14 @@ 
      */
     public function addBinding($value, $type = 'where')
     {
-        if (! array_key_exists($type, $this->bindings)) {
+        if (!array_key_exists($type, $this->bindings)) {
             throw new InvalidArgumentException("Invalid binding type: {$type}.");
         }
 
         if (is_array($value)) {
-            $this->bindings[$type] = array_values(array_merge($this->bindings[$type], $value));
+            $this->bindings[ $type ] = array_values(array_merge($this->bindings[ $type ], $value));
         } else {
-            $this->bindings[$type][] = $value;
+            $this->bindings[ $type ][ ] = $value;
         }
 
         return $this;
@@ -245,7 +245,7 @@ 
      * @param  array|mixed  $columns
      * @return $this
      */
-    public function select($columns = ['*'])
+    public function select($columns = [ '*' ])
     {
         $this->columns = is_array($columns) ? $columns : func_get_args();
 
@@ -257,7 +257,7 @@ 
      * @param array $bindings
      * @return mixed
      */
-    public function selectRaw(string $query, array $bindings = [])
+    public function selectRaw(string $query, array $bindings = [ ])
     {
         return $this->connection->select($query, $bindings);
     }
@@ -272,8 +272,8 @@ 
             return true;
         }
 
-        if (! is_array(reset($values))) {
-            $values = [$values];
+        if (!is_array(reset($values))) {
+            $values = [ $values ];
         }
 
         // Here, we will sort the insert keys for every record so that each insert is
@@ -282,18 +282,18 @@ 
         else {
             foreach ($values as $key => $value) {
                 ksort($value);
-                $values[$key] = $value;
+                $values[ $key ] = $value;
             }
         }
 
         // We'll treat every insert like a batch insert so we can easily insert each
         // of the records into the database consistently. This will make it much
         // easier on the grammars to just handle one type of record insertion.
-        $bindings = [];
+        $bindings = [ ];
 
         foreach ($values as $record) {
             foreach ($record as $value) {
-                $bindings[] = $value;
+                $bindings[ ] = $value;
             }
         }
 
@@ -348,7 +348,7 @@ 
     {
         $wrapped = $this->grammar->wrap($column);
 
-        $columns = array_merge([$column => $this->raw("$wrapped + $amount")]);
+        $columns = array_merge([ $column => $this->raw("$wrapped + $amount") ]);
 
         return $this->update($columns);
     }
@@ -364,7 +364,7 @@ 
     {
         $wrapped = $this->grammar->wrap($column);
 
-        $columns = array_merge([$column => $this->raw("$wrapped - $amount")]);
+        $columns = array_merge([ $column => $this->raw("$wrapped - $amount") ]);
 
         return $this->update($columns);
     }
@@ -380,7 +380,7 @@ 
         // If an ID is passed to the method, we will set the where clause to check
         // the ID to allow developers to simply and quickly remove a single row
         // from their database without manually specifying the where clauses.
-        if (! is_null($id)) {
+        if (!is_null($id)) {
             $this->where('id', '=', $id);
         }
 
@@ -406,7 +406,7 @@ 
      * @param array $bindings
      * @return bool
      */
-    public function insertRaw(string $query, array $bindings = [])
+    public function insertRaw(string $query, array $bindings = [ ])
     {
         return $this->connection->insert($query, $bindings);
     }
@@ -416,7 +416,7 @@ 
      * @param array $bindings
      * @return int
      */
-    public function updateRaw(string $query, array $bindings = [])
+    public function updateRaw(string $query, array $bindings = [ ])
     {
         return $this->connection->update($query, $bindings);
     }
@@ -426,7 +426,7 @@ 
      * @param array $bindings
      * @return int
      */
-    public function deleteRaw(string $query, array $bindings = [])
+    public function deleteRaw(string $query, array $bindings = [ ])
     {
         return $this->connection->delete($query, $bindings);
     }
@@ -466,7 +466,7 @@ 
         // passed to the method, we will assume that the operator is an equals sign
         // and keep going. Otherwise, we'll require the operator to be passed in.
         if (func_num_args() == 2) {
-            list($value, $operator) = [$operator, '='];
+            list($value, $operator) = [ $operator, '=' ];
         } elseif ($this->invalidOperatorAndValue($operator, $value)) {
             throw new InvalidArgumentException('Illegal operator and value combination.');
         }
@@ -474,8 +474,8 @@ 
         // If the given operator is not found in the list of valid operators we will
         // assume that the developer is just short-cutting the '=' operators and
         // we will set the operators to '=' and set the values appropriately.
-        if (! in_array(strtolower($operator), $this->operators, true)) {
-            list($value, $operator) = [$operator, '='];
+        if (!in_array(strtolower($operator), $this->operators, true)) {
+            list($value, $operator) = [ $operator, '=' ];
         }
 
         // If the value is a Closure, it means the developer is performing an entire
@@ -497,9 +497,9 @@ 
         // will be bound to each SQL statements when it is finally executed.
         $type = 'Basic';
 
-        $this->wheres[] = compact('type', 'column', 'operator', 'value', 'boolean');
+        $this->wheres[ ] = compact('type', 'column', 'operator', 'value', 'boolean');
 
-        if (! $value instanceof Expression) {
+        if (!$value instanceof Expression) {
             $this->addBinding($value, 'where');
         }
 
@@ -519,7 +519,7 @@ 
     {
         $type = 'in';
 
-        $this->wheres[] = compact('column', 'type', 'boolean', 'not');
+        $this->wheres[ ] = compact('column', 'type', 'boolean', 'not');
 
         $this->addBinding($values, 'where');
 
@@ -576,7 +576,7 @@ 
     {
         $type = 'between';
 
-        $this->wheres[] = compact('column', 'type', 'boolean', 'not');
+        $this->wheres[ ] = compact('column', 'type', 'boolean', 'not');
 
         $this->addBinding($values, 'where');
 
@@ -660,7 +660,7 @@ 
         if (count($query->wheres)) {
             $type = 'Nested';
 
-            $this->wheres[] = compact('type', 'query', 'boolean');
+            $this->wheres[ ] = compact('type', 'query', 'boolean');
 
             $this->addBinding($query->getBindings(), 'where');
         }
@@ -688,7 +688,7 @@ 
         // in the array of where clauses for the "main" parent query instance.
         call_user_func($callback, $query);
 
-        $this->wheres[] = compact('type', 'column', 'operator', 'query', 'boolean');
+        $this->wheres[ ] = compact('type', 'column', 'operator', 'query', 'boolean');
 
         $this->addBinding($query->getBindings(), 'where');
 
@@ -707,7 +707,7 @@ 
     {
         $type = 'Null';
 
-        $this->wheres[] = compact('type', 'column', 'boolean', 'not');
+        $this->wheres[ ] = compact('type', 'column', 'boolean', 'not');
 
         return $this;
     }
@@ -827,7 +827,7 @@ 
      */
     protected function addDateBasedWhere($type, $column, $operator, $value, $boolean = 'and')
     {
-        $this->wheres[] = compact('column', 'type', 'boolean', 'operator', 'value');
+        $this->wheres[ ] = compact('column', 'type', 'boolean', 'operator', 'value');
 
         $this->addBinding($value, 'where');
 
@@ -843,11 +843,11 @@ 
      */
     public function orderBy($column, $direction = 'asc')
     {
-        if(!($direction == 'asc' or $direction == 'desc')) {
+        if (!($direction == 'asc' or $direction == 'desc')) {
             handle(new Exception("Order by direction invalid: '".$direction."'"));
         }
 
-        $column = is_array($column) ? $column : [$column];
+        $column = is_array($column) ? $column : [ $column ];
 
         $this->orders = [
             $column,
@@ -891,7 +891,7 @@ 
      * @param array $columns
      * @return ArrayObject|null
      */
-    public function get(array $columns = ['*'])
+    public function get(array $columns = [ '*' ])
     {
         $this->columns = $columns;
 
@@ -956,11 +956,11 @@ 
      * @param array $columns
      * @return Model
      */
-    public function first(array $columns = ['*'])
+    public function first(array $columns = [ '*' ])
     {
         $this->limit(1);
 
-        return $this->get($columns)[0];
+        return $this->get($columns)[ 0 ];
     }
 
     /**
@@ -971,7 +971,7 @@ 
      */
     public function value(string $val)
     {
-        return $this->first([$val])->$val;
+        return $this->first([ $val ])->$val;
     }
 
     /**
@@ -982,8 +982,8 @@ 
      */
     public function count($columns = '*')
     {
-        if (! is_array($columns)) {
-            $columns = [$columns];
+        if (!is_array($columns)) {
+            $columns = [ $columns ];
         }
 
         return (int) $this->aggregate(__FUNCTION__, $columns);
@@ -997,7 +997,7 @@ 
      */
     public function min(string $column)
     {
-        return $this->aggregate(__FUNCTION__, [$column]);
+        return $this->aggregate(__FUNCTION__, [ $column ]);
     }
 
     /**
@@ -1008,7 +1008,7 @@ 
      */
     public function max($column)
     {
-        return $this->aggregate(__FUNCTION__, [$column]);
+        return $this->aggregate(__FUNCTION__, [ $column ]);
     }
 
     /**
@@ -1019,7 +1019,7 @@ 
      */
     public function sum($column)
     {
-        $result = $this->aggregate(__FUNCTION__, [$column]);
+        $result = $this->aggregate(__FUNCTION__, [ $column ]);
 
         return $result ?: 0;
     }
@@ -1032,7 +1032,7 @@ 
      */
     public function avg($column)
     {
-        return $this->aggregate(__FUNCTION__, [$column]);
+        return $this->aggregate(__FUNCTION__, [ $column ]);
     }
 
     /**
@@ -1067,10 +1067,10 @@ 
 
         $results = $this->connection->select($sql);
 
-        if (isset($results[0])) {
-            $results = (array) $results[0];
+        if (isset($results[ 0 ])) {
+            $results = (array) $results[ 0 ];
 
-            return (bool) $results['exists'];
+            return (bool) $results[ 'exists' ];
         }
 
         return false;
@@ -1083,7 +1083,7 @@ 
      */
     public function doesntExist()
     {
-        return ! $this->exists();
+        return !$this->exists();
     }
 
     /**
@@ -1093,7 +1093,7 @@ 
      * @param  array   $columns
      * @return float|int
      */
-    public function aggregate($function, $columns = ['*'])
+    public function aggregate($function, $columns = [ '*' ])
     {
         $this->aggregate = compact('function', 'columns');
 
@@ -1108,10 +1108,10 @@ 
 
         $this->columns = $previousColumns;
 
-        if (isset($results[0])) {
-            $result = array_change_key_case((array) $results[0]);
+        if (isset($results[ 0 ])) {
+            $result = array_change_key_case((array) $results[ 0 ]);
 
-            return $result['aggregate'];
+            return $result[ 'aggregate' ];
         }
     }
 
@@ -1126,7 +1126,7 @@ 
     private function isOperatorValid($operatorToCheck)
     {
         foreach ($this->operators as $operator) {
-            if($operatorToCheck === $operator) {
+            if ($operatorToCheck === $operator) {
                 return true;
             }
         }
@@ -1152,8 +1152,8 @@ 
      */
     protected function cleanBindings(array $bindings)
     {
-        return array_values(array_filter($bindings, function ($binding) {
-            return ! $binding instanceof Expression;
+        return array_values(array_filter($bindings, function($binding) {
+            return !$binding instanceof Expression;
         }));
     }
 
@@ -1167,13 +1167,13 @@ 
     protected function prepareRawQuery(string $query, array $bindings): string
     {
         // search for values in query
-        preg_match_all("/:([^ ]*)/", $query,$values);
+        preg_match_all("/:([^ ]*)/", $query, $values);
 
         // replace values with bindings
-        foreach ($values[1] as $value) {
+        foreach ($values[ 1 ] as $value) {
             // check if fitting binding exists
-            if(array_key_exists($value, $bindings)) {
-                $query = str_replace(":".$value, $bindings[$value], $query);
+            if (array_key_exists($value, $bindings)) {
+                $query = str_replace(":".$value, $bindings[ $value ], $query);
             } else {
                 handle(new Exception("Could not find fitting value '$value' in bindings for query: '$query'"));
             }

app/framework/Component/App/App.php

Spacing +15 added lines, -15 removed lines

@@ -23,15 +23,15 @@ 
     /**
      * @var array
      */
-    private $Instances = [];
+    private $Instances = [ ];
 
-    public function call($classMethod, $param = [])
+    public function call($classMethod, $param = [ ])
     {
         $method = null;
 
         $this->registerNewClass($classMethod, $method);
         try {
-            if($method == null)
+            if ($method == null)
                 throw new Exception("You have to specify an method to call");
         } catch (Exception $e) {
             handle($e);
@@ -45,13 +45,13 @@ 
         $method = null;
         $this->registerNewClass($className, $method);
 
-        return $this->Instances[$className];
+        return $this->Instances[ $className ];
     }
 
     private function checkIfClassIsRegistered($class)
     {
-        foreach($this->Instances as $Class){
-            if(get_class($Class) == $class){
+        foreach ($this->Instances as $Class) {
+            if (get_class($Class) == $class) {
                 return true;
             }
         }
@@ -60,33 +60,33 @@ 
 
     private function registerNewClass(&$class, &$method)
     {
-        $method = explode("@", $class)[1];
-        $class = self::validateClass(explode("@", $class)[0]);
+        $method = explode("@", $class)[ 1 ];
+        $class = self::validateClass(explode("@", $class)[ 0 ]);
 
         try {
-            if(! is_object($t_class = new $class))
+            if (!is_object($t_class = new $class))
                 throw new Exception("Could not instantiate class");
         } catch (Exception $e) {
             handle($e);
         } finally {
-            if(! self::checkIfClassIsRegistered($class)){
-                $this->Instances[$class] = new $class;
+            if (!self::checkIfClassIsRegistered($class)) {
+                $this->Instances[ $class ] = new $class;
             }
         }
     }
 
     private function callMethod($class, $method, $param)
     {
-        return call_user_func_array(array($this->Instances[$class], $method), $param);
+        return call_user_func_array(array($this->Instances[ $class ], $method), $param);
     }
 
     public function validateClass($class)
     {
         try {
-            foreach($this->defaultNamespaces as $namespace){
+            foreach ($this->defaultNamespaces as $namespace) {
                 //var_dump($namespace . "\\" . $class);
-                if(class_exists($namespace . "\\" . $class)){
-                    return $namespace . "\\" . $class;
+                if (class_exists($namespace."\\".$class)) {
+                    return $namespace."\\".$class;
                 } elseif (class_exists($class)) {
                     return $class;
                 }

app/framework/Component/Storage/File/File.php

Spacing +2 added lines, -2 removed lines

@@ -37,8 +37,8 @@
         $this->key     = $key;
 
         //make sure a file path is given
-        if (! $this->storage->keyExists($this->key) && ! $createIfDoesntExist) {
-            throw new StorageException(StorageException::FILE_NOT_FOUND, [$key]);
+        if (!$this->storage->keyExists($this->key) && !$createIfDoesntExist) {
+            throw new StorageException(StorageException::FILE_NOT_FOUND, [ $key ]);
         }
 
         if ($createIfDoesntExist) {