FramyFramework / Framy

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

Spacing +50 added lines, -50 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);
@@ -129,10 +129,10 @@ 
         // 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) {
-            $columns[] = $this->wrap($key)." = ?";
+            $columns[ ] = $this->wrap($key)." = ?";
         }
 
         $columns = implode(', ', $columns);
@@ -168,7 +168,7 @@ 
      */
     public function compileTruncate(Builder $query)
     {
-        return ['truncate '.$this->wrapTable($query->from) => []];
+        return [ 'truncate '.$this->wrapTable($query->from) => [ ] ];
     }
 
     /**
@@ -179,16 +179,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);
             }
         }
 
@@ -213,7 +213,7 @@ 
 
         $select = $query->distinct ? 'select distinct ' : 'select ';
 
-        return $select . $this->columnize($columns);
+        return $select.$this->columnize($columns);
     }
 
     /**
@@ -225,7 +225,7 @@ 
      */
     protected function compileFrom(Builder $query, $table)
     {
-        return 'from ' . $this->wrapTable($table);
+        return 'from '.$this->wrapTable($table);
     }
 
     /**
@@ -236,7 +236,7 @@ 
      */
     protected function compileWheres(Builder $query)
     {
-        $sql = [];
+        $sql = [ ];
 
         if (is_null($query->wheres)) {
             return '';
@@ -246,9 +246,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
@@ -272,7 +272,7 @@ 
      */
     protected function compileOrders(Builder $query, $orders)
     {
-        return 'order by '.implode(', ', $orders[0])." ".$orders[1];
+        return 'order by '.implode(', ', $orders[ 0 ])." ".$orders[ 1 ];
     }
 
     /**
@@ -296,7 +296,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
@@ -305,7 +305,7 @@ 
             $column = 'distinct '.$column;
         }
 
-        return 'select '.$aggregate['function'].'('.$column.') as aggregate';
+        return 'select '.$aggregate[ 'function' ].'('.$column.') as aggregate';
     }
 
     /**
@@ -337,7 +337,7 @@ 
     protected function whereBasic(Builder $query, $where)
     {
 //        $value = $this->parameter($where['value']);
-        return $this->wrap($where['column']).' '.$where['operator'].' ?'; //.$value;
+        return $this->wrap($where[ 'column' ]).' '.$where[ 'operator' ].' ?'; //.$value;
     }
 
     /**
@@ -349,9 +349,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 ?';
     }
 
     /**
@@ -363,18 +363,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;
     }
 
     /**
@@ -386,9 +386,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;
     }
 
     /**
@@ -400,7 +400,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' ];
     }
 
     /**
@@ -412,7 +412,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' ];
     }
 
     /**
@@ -424,7 +424,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' ];
     }
 
     /**
@@ -436,7 +436,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' ];
     }
 
     /**
@@ -447,8 +447,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 !== '';
         }));
     }
 
@@ -460,7 +460,7 @@ 
      */
     public function columnize(array $columns)
     {
-        return implode(', ', array_map([$this, 'wrap'], $columns));
+        return implode(', ', array_map([ $this, 'wrap' ], $columns));
     }
 
     /**
@@ -471,10 +471,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);
@@ -482,11 +482,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);
@@ -512,7 +512,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'";
@@ -527,7 +527,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);
@@ -553,13 +553,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);
 
@@ -568,9 +568,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);
             }
         }
 
@@ -592,11 +592,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 ]
             );
     }
 
@@ -608,7 +608,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);
@@ -624,7 +624,7 @@ 
     protected function wrapValue($value)
     {
         if ($value !== '*') {
-            return '`' . str_replace('"', '""', $value) . '`';
+            return '`'.str_replace('"', '""', $value).'`';
         }
 
         return $value;

app/framework/Component/Database/Model/Model.php

Spacing +21 added lines, -21 removed lines

@@ -78,14 +78,14 @@ 
      *
      * @var array
      */
-    protected $attributes = [];
+    protected $attributes = [ ];
 
     /**
      * The model attribute's original state.
      *
      * @var array
      */
-    protected $original = [];
+    protected $original = [ ];
 
     /**
      * The number of models to return for pagination.
@@ -120,7 +120,7 @@ 
      * Model constructor.
      * @param array $attributes
      */
-    public function __construct(array $attributes = [])
+    public function __construct(array $attributes = [ ])
     {
         $this->bootIfNotBooted();
 
@@ -139,7 +139,7 @@ 
      */
     public function bootIfNotBooted()
     {
-        if (! self::$isBooted) {
+        if (!self::$isBooted) {
             self::boot();
 
             self::$isBooted = true;
@@ -166,7 +166,7 @@ 
      */
     public function syncOriginalAttribute($attribute)
     {
-        $this->original[$attribute] = $this->attributes[$attribute];
+        $this->original[ $attribute ] = $this->attributes[ $attribute ];
 
         return $this;
     }
@@ -293,13 +293,13 @@ 
      * @param array $columns
      * @return mixed
      */
-    public static function all(array $columns = ['*'])
+    public static function all(array $columns = [ '*' ])
     {
         $instance = new static();
         /** @var ArrayObject $result */
         $result   = $instance->newQuery()->get($columns);
 
-        $result->map(function ($item) {
+        $result->map(function($item) {
             $item->exists = true;
         });
 
@@ -315,7 +315,7 @@ 
         $instance = new static();
         $result   = $instance->newQuery()->find($id);
 
-        if (! is_null($result)) {
+        if (!is_null($result)) {
             $result->exists = true;
         }
 
@@ -351,8 +351,8 @@ 
     {
         $instance = new static();
 
-        if (! is_array($id)) {
-            $id = [$id];
+        if (!is_array($id)) {
+            $id = [ $id ];
         }
 
         return $instance->newQuery()->remove($id);
@@ -382,7 +382,7 @@ 
      */
     public function setAttribute($key, $value)
     {
-        $this->attributes[$key] = $value;
+        $this->attributes[ $key ] = $value;
 
         return $this;
     }
@@ -400,11 +400,11 @@ 
      */
     public function getAttribute($key)
     {
-        if (! $key) {
+        if (!$key) {
             return;
         }
 
-        $attr = $this->getAttributes()[$key];
+        $attr = $this->getAttributes()[ $key ];
 
         if (isset($attr)) {
             return $attr;
@@ -576,7 +576,7 @@ 
      */
     public function offsetExists($offset)
     {
-        return isset($this->attributes[$offset]);
+        return isset($this->attributes[ $offset ]);
     }
 
     /**
@@ -590,7 +590,7 @@ 
      */
     public function offsetGet($offset)
     {
-        return $this->attributes[$offset];
+        return $this->attributes[ $offset ];
     }
 
     /**
@@ -607,7 +607,7 @@ 
      */
     public function offsetSet($offset, $value)
     {
-        $this->attributes[$offset] = $value;
+        $this->attributes[ $offset ] = $value;
     }
 
     /**
@@ -621,7 +621,7 @@ 
      */
     public function offsetUnset($offset)
     {
-        unset($this->attributes[$offset]);
+        unset($this->attributes[ $offset ]);
     }
 
     /**
@@ -689,11 +689,11 @@ 
     {
         $time = $this->freshTimestamp();
 
-        if (! is_null(static::UPDATED_AT) ) {
+        if (!is_null(static::UPDATED_AT)) {
             $this->setUpdatedAt($time);
         }
 
-        if (! is_null(static::CREATED_AT)) {
+        if (!is_null(static::CREATED_AT)) {
             $this->setCreatedAt($time);
         }
     }
@@ -749,12 +749,12 @@ 
      */
     private function getDifference()
     {
-        $attributes = [];
+        $attributes = [ ];
         foreach ($this->getAttributes() as $attKey => $attribute) {
             foreach ($this->original as $oriKey => $original) {
                 if ($attKey == $oriKey) {
                     if ($attribute !== $original) {
-                        $attributes[$attKey] = $attribute;
+                        $attributes[ $attKey ] = $attribute;
                     }
                 }
             }