pryley / site-reviews

plugin/Database/QuerySql.php

Indentation +245 added lines, -245 removed lines

@@ -7,249 +7,249 @@
 
 trait QuerySql
 {
-    public $args;
-    public $db;
-
-    public function escFieldsForInsert(array $fields)
-    {
-        return sprintf('(`%s`)', implode('`,`', $fields));
-    }
-
-    public function escValuesForInsert(array $values)
-    {
-        $values = array_map('esc_sql', $values);
-        return sprintf("('%s')", implode("','", array_values($values)));
-    }
-
-    /**
-     * @param string $clause
-     * @return array
-     */
-    public function sqlClauses(array $values, $clause)
-    {
-        $prefix = Str::restrictTo('and, join', $clause);
-        foreach (array_keys($this->args) as $key) {
-            $method = Helper::buildMethodName($key, 'clause-'.$prefix);
-            if (method_exists($this, $method)) {
-                $values[] = call_user_func([$this, $method]);
-            }
-        }
-        return $values;
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlFrom()
-    {
-        $from = "FROM {$this->table('ratings')} r";
-        $from = glsr()->filterString('query/sql/from', $from, $this);
-        return $from;
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlGroupBy()
-    {
-        $groupBy = 'GROUP BY p.ID';
-        return glsr()->filterString('query/sql/group-by', $groupBy, $this);
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlJoin()
-    {
-        $join = [
-            "INNER JOIN {$this->db->posts} AS p ON r.review_id = p.ID",
-        ];
-        $join = glsr()->filterArray('query/sql/join', $join, $this);
-        return implode(' ', $join);
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlJoinClauses()
-    {
-        $join = $this->sqlClauses([], 'join');
-        $join = glsr()->filterArray('query/sql/join-clauses', $join, $this);
-        return trim($this->sqlJoin().' '.implode(' ', $join));
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlJoinPivots()
-    {
-        $join = [
-            "LEFT JOIN {$this->table('assigned_posts')} apt on r.ID = apt.rating_id",
-            "LEFT JOIN {$this->table('assigned_terms')} att on r.ID = att.rating_id",
-            "LEFT JOIN {$this->table('assigned_users')} aut on r.ID = aut.rating_id",
-        ];
-        $join = glsr()->filterArray('query/sql/join-pivots', $join, $this);
-        return implode(' ', $join);
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlLimit()
-    {
-        $limit = $this->args['per_page'] > 0
-            ? $this->db->prepare('LIMIT %d', $this->args['per_page'])
-            : '';
-        return glsr()->filterString('query/sql/limit', $limit, $this);
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlOffset()
-    {
-        $offsetBy = (($this->args['page'] - 1) * $this->args['per_page']) + $this->args['offset'];
-        $offset = ($offsetBy > 0)
-            ? $this->db->prepare('OFFSET %d', $offsetBy)
-            : '';
-        return glsr()->filterString('query/sql/offset', $offset, $this);
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlOrderBy()
-    {
-        $values = [
-            'none' => '',
-            'rand' => 'ORDER BY RAND()',
-            'relevance' => '',
-        ];
-        $order = $this->args['order'];
-        $orderby = $this->args['orderby'];
-        if (Str::startsWith('p.', $orderby)) {
-            $orderBy = "ORDER BY r.is_pinned {$order}, {$orderby} {$order}";
-        } elseif (array_key_exists($orderby, $values)) {
-            $orderBy = $orderby;
-        } else {
-            $orderBy = '';
-        }
-        return glsr()->filterString('query/sql/order-by', $orderBy, $this);
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlSelect()
-    {
-        $select = [
-            'r.*',
-            'p.post_author as author_id',
-            'p.post_date as date',
-            'p.post_content as content',
-            'p.post_title as title',
-            'p.post_status as status',
-            'GROUP_CONCAT(DISTINCT apt.post_id) as post_ids',
-            'GROUP_CONCAT(DISTINCT att.term_id) as term_ids',
-            'GROUP_CONCAT(DISTINCT aut.user_id) as user_ids',
-        ];
-        $select = glsr()->filterArray('query/sql/select', $select, $this);
-        $select = implode(', ', $select);
-        return "SELECT {$select}";
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlWhere()
-    {
-        $where = [
-            $this->db->prepare('AND p.post_type = %s', glsr()->post_type),
-            "AND p.post_status = 'publish'",
-        ];
-        $where = $this->sqlClauses($where, 'and');
-        $where = glsr()->filterArray('query/sql/where', $where, $this);
-        $where = implode(' ', $where);
-        return "WHERE 1=1 {$where}";
-    }
-
-    /**
-     * @return string
-     */
-    public function table($table)
-    {
-        return glsr(SqlSchema::class)->table($table);
-    }
-
-    /**
-     * This takes care of assigned_to, category, and user.
-     * @return string
-     */
-    protected function clauseAndAssignedTo()
-    {
-        $clauses = [];
-        if ($postIds = $this->args['assigned_to']) {
-            $clauses[] = $this->db->prepare('(apt.post_id IN (%s) AND apt.is_published = 1)', implode(',', $postIds));
-        }
-        if ($termIds = $this->args['category']) {
-            $clauses[] = $this->db->prepare('(att.term_id IN (%s))', implode(',', $termIds));
-        }
-        if ($userIds = $this->args['user']) {
-            $clauses[] = $this->db->prepare('(aut.user_id IN (%s))', implode(',', $userIds));
-        }
-        if ($clauses = implode(' OR ', $clauses)) {
-            return "AND ($clauses)";
-        }
-        return '';
-    }
-
-    /**
-     * @return string
-     */
-    protected function clauseAndRating()
-    {
-        return $this->args['rating']
-            ? $this->db->prepare('AND r.rating > %d', --$this->args['rating'])
-            : '';
-    }
-
-    /**
-     * @return string
-     */
-    protected function clauseAndType()
-    {
-        return $this->args['type']
-            ? $this->db->prepare('AND r.type = %s', $this->args['type'])
-            : '';
-    }
-
-    /**
-     * @return string
-     */
-    protected function clauseJoinAssignedTo()
-    {
-        return !empty($this->args['assigned_to'])
-            ? "INNER JOIN {$this->table('assigned_posts')} AS apt ON r.ID = apt.rating_id"
-            : '';
-    }
-
-    /**
-     * @return string
-     */
-    protected function clauseJoinCategory()
-    {
-        return !empty($this->args['category'])
-            ? "INNER JOIN {$this->table('assigned_terms')} AS att ON r.ID = att.rating_id"
-            : '';
-    }
-
-    /**
-     * @return string
-     */
-    protected function clauseJoinUser()
-    {
-        return !empty($this->args['user'])
-            ? "INNER JOIN {$this->table('assigned_users')} AS aut ON r.ID = aut.rating_id"
-            : '';
-    }
+	public $args;
+	public $db;
+
+	public function escFieldsForInsert(array $fields)
+	{
+		return sprintf('(`%s`)', implode('`,`', $fields));
+	}
+
+	public function escValuesForInsert(array $values)
+	{
+		$values = array_map('esc_sql', $values);
+		return sprintf("('%s')", implode("','", array_values($values)));
+	}
+
+	/**
+	 * @param string $clause
+	 * @return array
+	 */
+	public function sqlClauses(array $values, $clause)
+	{
+		$prefix = Str::restrictTo('and, join', $clause);
+		foreach (array_keys($this->args) as $key) {
+			$method = Helper::buildMethodName($key, 'clause-'.$prefix);
+			if (method_exists($this, $method)) {
+				$values[] = call_user_func([$this, $method]);
+			}
+		}
+		return $values;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlFrom()
+	{
+		$from = "FROM {$this->table('ratings')} r";
+		$from = glsr()->filterString('query/sql/from', $from, $this);
+		return $from;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlGroupBy()
+	{
+		$groupBy = 'GROUP BY p.ID';
+		return glsr()->filterString('query/sql/group-by', $groupBy, $this);
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlJoin()
+	{
+		$join = [
+			"INNER JOIN {$this->db->posts} AS p ON r.review_id = p.ID",
+		];
+		$join = glsr()->filterArray('query/sql/join', $join, $this);
+		return implode(' ', $join);
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlJoinClauses()
+	{
+		$join = $this->sqlClauses([], 'join');
+		$join = glsr()->filterArray('query/sql/join-clauses', $join, $this);
+		return trim($this->sqlJoin().' '.implode(' ', $join));
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlJoinPivots()
+	{
+		$join = [
+			"LEFT JOIN {$this->table('assigned_posts')} apt on r.ID = apt.rating_id",
+			"LEFT JOIN {$this->table('assigned_terms')} att on r.ID = att.rating_id",
+			"LEFT JOIN {$this->table('assigned_users')} aut on r.ID = aut.rating_id",
+		];
+		$join = glsr()->filterArray('query/sql/join-pivots', $join, $this);
+		return implode(' ', $join);
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlLimit()
+	{
+		$limit = $this->args['per_page'] > 0
+			? $this->db->prepare('LIMIT %d', $this->args['per_page'])
+			: '';
+		return glsr()->filterString('query/sql/limit', $limit, $this);
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlOffset()
+	{
+		$offsetBy = (($this->args['page'] - 1) * $this->args['per_page']) + $this->args['offset'];
+		$offset = ($offsetBy > 0)
+			? $this->db->prepare('OFFSET %d', $offsetBy)
+			: '';
+		return glsr()->filterString('query/sql/offset', $offset, $this);
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlOrderBy()
+	{
+		$values = [
+			'none' => '',
+			'rand' => 'ORDER BY RAND()',
+			'relevance' => '',
+		];
+		$order = $this->args['order'];
+		$orderby = $this->args['orderby'];
+		if (Str::startsWith('p.', $orderby)) {
+			$orderBy = "ORDER BY r.is_pinned {$order}, {$orderby} {$order}";
+		} elseif (array_key_exists($orderby, $values)) {
+			$orderBy = $orderby;
+		} else {
+			$orderBy = '';
+		}
+		return glsr()->filterString('query/sql/order-by', $orderBy, $this);
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlSelect()
+	{
+		$select = [
+			'r.*',
+			'p.post_author as author_id',
+			'p.post_date as date',
+			'p.post_content as content',
+			'p.post_title as title',
+			'p.post_status as status',
+			'GROUP_CONCAT(DISTINCT apt.post_id) as post_ids',
+			'GROUP_CONCAT(DISTINCT att.term_id) as term_ids',
+			'GROUP_CONCAT(DISTINCT aut.user_id) as user_ids',
+		];
+		$select = glsr()->filterArray('query/sql/select', $select, $this);
+		$select = implode(', ', $select);
+		return "SELECT {$select}";
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlWhere()
+	{
+		$where = [
+			$this->db->prepare('AND p.post_type = %s', glsr()->post_type),
+			"AND p.post_status = 'publish'",
+		];
+		$where = $this->sqlClauses($where, 'and');
+		$where = glsr()->filterArray('query/sql/where', $where, $this);
+		$where = implode(' ', $where);
+		return "WHERE 1=1 {$where}";
+	}
+
+	/**
+	 * @return string
+	 */
+	public function table($table)
+	{
+		return glsr(SqlSchema::class)->table($table);
+	}
+
+	/**
+	 * This takes care of assigned_to, category, and user.
+	 * @return string
+	 */
+	protected function clauseAndAssignedTo()
+	{
+		$clauses = [];
+		if ($postIds = $this->args['assigned_to']) {
+			$clauses[] = $this->db->prepare('(apt.post_id IN (%s) AND apt.is_published = 1)', implode(',', $postIds));
+		}
+		if ($termIds = $this->args['category']) {
+			$clauses[] = $this->db->prepare('(att.term_id IN (%s))', implode(',', $termIds));
+		}
+		if ($userIds = $this->args['user']) {
+			$clauses[] = $this->db->prepare('(aut.user_id IN (%s))', implode(',', $userIds));
+		}
+		if ($clauses = implode(' OR ', $clauses)) {
+			return "AND ($clauses)";
+		}
+		return '';
+	}
+
+	/**
+	 * @return string
+	 */
+	protected function clauseAndRating()
+	{
+		return $this->args['rating']
+			? $this->db->prepare('AND r.rating > %d', --$this->args['rating'])
+			: '';
+	}
+
+	/**
+	 * @return string
+	 */
+	protected function clauseAndType()
+	{
+		return $this->args['type']
+			? $this->db->prepare('AND r.type = %s', $this->args['type'])
+			: '';
+	}
+
+	/**
+	 * @return string
+	 */
+	protected function clauseJoinAssignedTo()
+	{
+		return !empty($this->args['assigned_to'])
+			? "INNER JOIN {$this->table('assigned_posts')} AS apt ON r.ID = apt.rating_id"
+			: '';
+	}
+
+	/**
+	 * @return string
+	 */
+	protected function clauseJoinCategory()
+	{
+		return !empty($this->args['category'])
+			? "INNER JOIN {$this->table('assigned_terms')} AS att ON r.ID = att.rating_id"
+			: '';
+	}
+
+	/**
+	 * @return string
+	 */
+	protected function clauseJoinUser()
+	{
+		return !empty($this->args['user'])
+			? "INNER JOIN {$this->table('assigned_users')} AS aut ON r.ID = aut.rating_id"
+			: '';
+	}
 }

Spacing +51 added lines, -51 removed lines

@@ -10,28 +10,28 @@ 
     public $args;
     public $db;
 
-    public function escFieldsForInsert(array $fields)
+    public function escFieldsForInsert( array $fields )
     {
-        return sprintf('(`%s`)', implode('`,`', $fields));
+        return sprintf( '(`%s`)', implode( '`,`', $fields ) );
     }
 
-    public function escValuesForInsert(array $values)
+    public function escValuesForInsert( array $values )
     {
-        $values = array_map('esc_sql', $values);
-        return sprintf("('%s')", implode("','", array_values($values)));
+        $values = array_map( 'esc_sql', $values );
+        return sprintf( "('%s')", implode( "','", array_values( $values ) ) );
     }
 
     /**
      * @param string $clause
      * @return array
      */
-    public function sqlClauses(array $values, $clause)
+    public function sqlClauses( array $values, $clause )
     {
-        $prefix = Str::restrictTo('and, join', $clause);
-        foreach (array_keys($this->args) as $key) {
-            $method = Helper::buildMethodName($key, 'clause-'.$prefix);
-            if (method_exists($this, $method)) {
-                $values[] = call_user_func([$this, $method]);
+        $prefix = Str::restrictTo( 'and, join', $clause );
+        foreach( array_keys( $this->args ) as $key ) {
+            $method = Helper::buildMethodName( $key, 'clause-'.$prefix );
+            if( method_exists( $this, $method ) ) {
+                $values[] = call_user_func( [$this, $method] );
             }
         }
         return $values;
@@ -42,8 +42,8 @@ 
      */
     public function sqlFrom()
     {
-        $from = "FROM {$this->table('ratings')} r";
-        $from = glsr()->filterString('query/sql/from', $from, $this);
+        $from = "FROM {$this->table( 'ratings' )} r";
+        $from = glsr()->filterString( 'query/sql/from', $from, $this );
         return $from;
     }
 
@@ -53,7 +53,7 @@ 
     public function sqlGroupBy()
     {
         $groupBy = 'GROUP BY p.ID';
-        return glsr()->filterString('query/sql/group-by', $groupBy, $this);
+        return glsr()->filterString( 'query/sql/group-by', $groupBy, $this );
     }
 
     /**
@@ -64,8 +64,8 @@ 
         $join = [
             "INNER JOIN {$this->db->posts} AS p ON r.review_id = p.ID",
         ];
-        $join = glsr()->filterArray('query/sql/join', $join, $this);
-        return implode(' ', $join);
+        $join = glsr()->filterArray( 'query/sql/join', $join, $this );
+        return implode( ' ', $join );
     }
 
     /**
@@ -73,9 +73,9 @@ 
      */
     public function sqlJoinClauses()
     {
-        $join = $this->sqlClauses([], 'join');
-        $join = glsr()->filterArray('query/sql/join-clauses', $join, $this);
-        return trim($this->sqlJoin().' '.implode(' ', $join));
+        $join = $this->sqlClauses( [], 'join' );
+        $join = glsr()->filterArray( 'query/sql/join-clauses', $join, $this );
+        return trim( $this->sqlJoin().' '.implode( ' ', $join ) );
     }
 
     /**
@@ -84,12 +84,12 @@ 
     public function sqlJoinPivots()
     {
         $join = [
-            "LEFT JOIN {$this->table('assigned_posts')} apt on r.ID = apt.rating_id",
-            "LEFT JOIN {$this->table('assigned_terms')} att on r.ID = att.rating_id",
-            "LEFT JOIN {$this->table('assigned_users')} aut on r.ID = aut.rating_id",
+            "LEFT JOIN {$this->table( 'assigned_posts' )} apt on r.ID = apt.rating_id",
+            "LEFT JOIN {$this->table( 'assigned_terms' )} att on r.ID = att.rating_id",
+            "LEFT JOIN {$this->table( 'assigned_users' )} aut on r.ID = aut.rating_id",
         ];
-        $join = glsr()->filterArray('query/sql/join-pivots', $join, $this);
-        return implode(' ', $join);
+        $join = glsr()->filterArray( 'query/sql/join-pivots', $join, $this );
+        return implode( ' ', $join );
     }
 
     /**
@@ -98,9 +98,9 @@ 
     public function sqlLimit()
     {
         $limit = $this->args['per_page'] > 0
-            ? $this->db->prepare('LIMIT %d', $this->args['per_page'])
+            ? $this->db->prepare( 'LIMIT %d', $this->args['per_page'] )
             : '';
-        return glsr()->filterString('query/sql/limit', $limit, $this);
+        return glsr()->filterString( 'query/sql/limit', $limit, $this );
     }
 
     /**
@@ -110,9 +110,9 @@ 
     {
         $offsetBy = (($this->args['page'] - 1) * $this->args['per_page']) + $this->args['offset'];
         $offset = ($offsetBy > 0)
-            ? $this->db->prepare('OFFSET %d', $offsetBy)
+            ? $this->db->prepare( 'OFFSET %d', $offsetBy )
             : '';
-        return glsr()->filterString('query/sql/offset', $offset, $this);
+        return glsr()->filterString( 'query/sql/offset', $offset, $this );
     }
 
     /**
@@ -127,14 +127,14 @@ 
         ];
         $order = $this->args['order'];
         $orderby = $this->args['orderby'];
-        if (Str::startsWith('p.', $orderby)) {
+        if( Str::startsWith( 'p.', $orderby ) ) {
             $orderBy = "ORDER BY r.is_pinned {$order}, {$orderby} {$order}";
-        } elseif (array_key_exists($orderby, $values)) {
+        } elseif( array_key_exists( $orderby, $values ) ) {
             $orderBy = $orderby;
         } else {
             $orderBy = '';
         }
-        return glsr()->filterString('query/sql/order-by', $orderBy, $this);
+        return glsr()->filterString( 'query/sql/order-by', $orderBy, $this );
     }
 
     /**
@@ -153,8 +153,8 @@ 
             'GROUP_CONCAT(DISTINCT att.term_id) as term_ids',
             'GROUP_CONCAT(DISTINCT aut.user_id) as user_ids',
         ];
-        $select = glsr()->filterArray('query/sql/select', $select, $this);
-        $select = implode(', ', $select);
+        $select = glsr()->filterArray( 'query/sql/select', $select, $this );
+        $select = implode( ', ', $select );
         return "SELECT {$select}";
     }
 
@@ -164,21 +164,21 @@ 
     public function sqlWhere()
     {
         $where = [
-            $this->db->prepare('AND p.post_type = %s', glsr()->post_type),
+            $this->db->prepare( 'AND p.post_type = %s', glsr()->post_type ),
             "AND p.post_status = 'publish'",
         ];
-        $where = $this->sqlClauses($where, 'and');
-        $where = glsr()->filterArray('query/sql/where', $where, $this);
-        $where = implode(' ', $where);
+        $where = $this->sqlClauses( $where, 'and' );
+        $where = glsr()->filterArray( 'query/sql/where', $where, $this );
+        $where = implode( ' ', $where );
         return "WHERE 1=1 {$where}";
     }
 
     /**
      * @return string
      */
-    public function table($table)
+    public function table( $table )
     {
-        return glsr(SqlSchema::class)->table($table);
+        return glsr( SqlSchema::class )->table( $table );
     }
 
     /**
@@ -188,16 +188,16 @@ 
     protected function clauseAndAssignedTo()
     {
         $clauses = [];
-        if ($postIds = $this->args['assigned_to']) {
-            $clauses[] = $this->db->prepare('(apt.post_id IN (%s) AND apt.is_published = 1)', implode(',', $postIds));
+        if( $postIds = $this->args['assigned_to'] ) {
+            $clauses[] = $this->db->prepare( '(apt.post_id IN (%s) AND apt.is_published = 1)', implode( ',', $postIds ) );
         }
-        if ($termIds = $this->args['category']) {
-            $clauses[] = $this->db->prepare('(att.term_id IN (%s))', implode(',', $termIds));
+        if( $termIds = $this->args['category'] ) {
+            $clauses[] = $this->db->prepare( '(att.term_id IN (%s))', implode( ',', $termIds ) );
         }
-        if ($userIds = $this->args['user']) {
-            $clauses[] = $this->db->prepare('(aut.user_id IN (%s))', implode(',', $userIds));
+        if( $userIds = $this->args['user'] ) {
+            $clauses[] = $this->db->prepare( '(aut.user_id IN (%s))', implode( ',', $userIds ) );
         }
-        if ($clauses = implode(' OR ', $clauses)) {
+        if( $clauses = implode( ' OR ', $clauses ) ) {
             return "AND ($clauses)";
         }
         return '';
@@ -209,7 +209,7 @@ 
     protected function clauseAndRating()
     {
         return $this->args['rating']
-            ? $this->db->prepare('AND r.rating > %d', --$this->args['rating'])
+            ? $this->db->prepare( 'AND r.rating > %d', --$this->args['rating'] )
             : '';
     }
 
@@ -219,7 +219,7 @@ 
     protected function clauseAndType()
     {
         return $this->args['type']
-            ? $this->db->prepare('AND r.type = %s', $this->args['type'])
+            ? $this->db->prepare( 'AND r.type = %s', $this->args['type'] )
             : '';
     }
 
@@ -229,7 +229,7 @@ 
     protected function clauseJoinAssignedTo()
     {
         return !empty($this->args['assigned_to'])
-            ? "INNER JOIN {$this->table('assigned_posts')} AS apt ON r.ID = apt.rating_id"
+            ? "INNER JOIN {$this->table( 'assigned_posts' )} AS apt ON r.ID = apt.rating_id"
             : '';
     }
 
@@ -239,7 +239,7 @@ 
     protected function clauseJoinCategory()
     {
         return !empty($this->args['category'])
-            ? "INNER JOIN {$this->table('assigned_terms')} AS att ON r.ID = att.rating_id"
+            ? "INNER JOIN {$this->table( 'assigned_terms' )} AS att ON r.ID = att.rating_id"
             : '';
     }
 
@@ -249,7 +249,7 @@ 
     protected function clauseJoinUser()
     {
         return !empty($this->args['user'])
-            ? "INNER JOIN {$this->table('assigned_users')} AS aut ON r.ID = aut.rating_id"
+            ? "INNER JOIN {$this->table( 'assigned_users' )} AS aut ON r.ID = aut.rating_id"
             : '';
     }
 }

Upper-Lower-Casing +2 added lines, -2 removed lines

@@ -42,7 +42,7 @@ 
      */
     public function sqlFrom()
     {
-        $from = "FROM {$this->table('ratings')} r";
+        $from = "from {$this->table('ratings')} r";
         $from = glsr()->filterString('query/sql/from', $from, $this);
         return $from;
     }
@@ -155,7 +155,7 @@ 
         ];
         $select = glsr()->filterArray('query/sql/select', $select, $this);
         $select = implode(', ', $select);
-        return "SELECT {$select}";
+        return "select {$select}";
     }
 
     /**

plugin/Database/SqlQueries.php

Indentation +173 added lines, -173 removed lines

@@ -10,47 +10,47 @@ 
 
 class SqlQueries
 {
-    protected $db;
-    protected $postType;
+	protected $db;
+	protected $postType;
 
-    public function __construct()
-    {
-        global $wpdb;
-        $this->db = $wpdb;
-        $this->postType = Application::POST_TYPE;
-    }
+	public function __construct()
+	{
+		global $wpdb;
+		$this->db = $wpdb;
+		$this->postType = Application::POST_TYPE;
+	}
 
-    /**
-     * @return bool
-     */
-    public function deletePostCountMetaKeys()
-    {
-        return $this->db->query("
+	/**
+	 * @return bool
+	 */
+	public function deletePostCountMetaKeys()
+	{
+		return $this->db->query("
             DELETE
             FROM {$this->db->postmeta}
             WHERE meta_key LIKE '_glsr_%'
         ");
-    }
+	}
 
-    /**
-     * @return bool
-     */
-    public function deleteTermCountMetaKeys()
-    {
-        return $this->db->query("
+	/**
+	 * @return bool
+	 */
+	public function deleteTermCountMetaKeys()
+	{
+		return $this->db->query("
             DELETE
             FROM {$this->db->termmeta}
             WHERE meta_key LIKE '_glsr_%'
         ");
-    }
+	}
 
-    /**
-     * @param string $metaReviewId
-     * @return int
-     */
-    public function getPostIdFromReviewId($metaReviewId)
-    {
-        $postId = $this->db->get_var("
+	/**
+	 * @param string $metaReviewId
+	 * @return int
+	 */
+	public function getPostIdFromReviewId($metaReviewId)
+	{
+		$postId = $this->db->get_var("
             SELECT p.ID
             FROM {$this->db->posts} AS p
             INNER JOIN {$this->db->postmeta} AS m ON p.ID = m.post_id
@@ -58,18 +58,18 @@ 
             AND m.meta_key = '_review_id'
             AND m.meta_value = '{$metaReviewId}'
         ");
-        return intval($postId);
-    }
+		return intval($postId);
+	}
 
-    /**
-     * @return array
-     */
-    public function getRatings(array $args)
-    {
-        // get types
-        // get for each type
-        $table = glsr(SqlSchema::class)->table('ratings');
-        return (array) $this->db->get_results("
+	/**
+	 * @return array
+	 */
+	public function getRatings(array $args)
+	{
+		// get types
+		// get for each type
+		$table = glsr(SqlSchema::class)->table('ratings');
+		return (array) $this->db->get_results("
             SELECT r.rating AS rating, COUNT(r.rating) AS count
             FROM {$table} AS r
             {$this->getInnerJoinForRatings($args)}
@@ -77,16 +77,16 @@ 
             {$this->getAndForRatings($args)}
             GROUP BY rating
         ");
-    }
+	}
 
-    /**
-     * @param int $lastPostId
-     * @param int $limit
-     * @return array
-     */
-    public function getReviewCounts(array $args, $lastPostId = 0, $limit = 500)
-    {
-        return (array) $this->db->get_results("
+	/**
+	 * @param int $lastPostId
+	 * @param int $limit
+	 * @return array
+	 */
+	public function getReviewCounts(array $args, $lastPostId = 0, $limit = 500)
+	{
+		return (array) $this->db->get_results("
             SELECT DISTINCT p.ID, m1.meta_value AS rating, m2.meta_value AS type
             FROM {$this->db->posts} AS p
             INNER JOIN {$this->db->postmeta} AS m1 ON p.ID = m1.post_id
@@ -101,17 +101,17 @@ 
             ORDER By p.ID ASC
             LIMIT {$limit}
         ");
-    }
+	}
 
-    /**
-     * @todo remove this?
-     * @param string $metaKey
-     * @return array
-     */
-    public function getReviewCountsFor($metaKey)
-    {
-        $metaKey = Str::prefix('_', $metaKey);
-        return (array) $this->db->get_results("
+	/**
+	 * @todo remove this?
+	 * @param string $metaKey
+	 * @return array
+	 */
+	public function getReviewCountsFor($metaKey)
+	{
+		$metaKey = Str::prefix('_', $metaKey);
+		return (array) $this->db->get_results("
             SELECT DISTINCT m.meta_value AS name, COUNT(*) num_posts
             FROM {$this->db->posts} AS p
             INNER JOIN {$this->db->postmeta} AS m ON p.ID = m.post_id
@@ -119,16 +119,16 @@ 
             AND m.meta_key = '{$metaKey}'
             GROUP BY name
         ");
-    }
+	}
 
-    /**
-     * @todo remove this?
-     * @param string $reviewType
-     * @return array
-     */
-    public function getReviewIdsByType($reviewType)
-    {
-        $results = $this->db->get_col("
+	/**
+	 * @todo remove this?
+	 * @param string $reviewType
+	 * @return array
+	 */
+	public function getReviewIdsByType($reviewType)
+	{
+		$results = $this->db->get_col("
             SELECT DISTINCT m1.meta_value AS review_id
             FROM {$this->db->posts} AS p
             INNER JOIN {$this->db->postmeta} AS m1 ON p.ID = m1.post_id
@@ -138,20 +138,20 @@ 
             AND m2.meta_key = '_review_type'
             AND m2.meta_value = '{$reviewType}'
         ");
-        return array_keys(array_flip($results));
-    }
+		return array_keys(array_flip($results));
+	}
 
-    /**
-     * @param int $greaterThanId
-     * @param int $limit
-     * @return array
-     */
-    public function getReviewRatingsFromIds(array $postIds, $greaterThanId = 0, $limit = 100)
-    {
-        sort($postIds);
-        $postIds = array_slice($postIds, intval(array_search($greaterThanId, $postIds)), $limit);
-        $postIds = implode(',', $postIds);
-        return (array) $this->db->get_results("
+	/**
+	 * @param int $greaterThanId
+	 * @param int $limit
+	 * @return array
+	 */
+	public function getReviewRatingsFromIds(array $postIds, $greaterThanId = 0, $limit = 100)
+	{
+		sort($postIds);
+		$postIds = array_slice($postIds, intval(array_search($greaterThanId, $postIds)), $limit);
+		$postIds = implode(',', $postIds);
+		return (array) $this->db->get_results("
             SELECT p.ID, m.meta_value AS rating
             FROM {$this->db->posts} AS p
             INNER JOIN {$this->db->postmeta} AS m ON p.ID = m.post_id
@@ -164,20 +164,20 @@ 
             ORDER By p.ID ASC
             LIMIT {$limit}
         ");
-    }
+	}
 
-    /**
-     * @param string $key
-     * @param string $status
-     * @return array
-     */
-    public function getReviewsMeta($key, $status = 'publish')
-    {
-        $postStatusQuery = 'all' != $status && !empty($status)
-            ? "AND p.post_status = '{$status}'"
-            : '';
-        $key = Str::prefix('_', $key);
-        $values = $this->db->get_col("
+	/**
+	 * @param string $key
+	 * @param string $status
+	 * @return array
+	 */
+	public function getReviewsMeta($key, $status = 'publish')
+	{
+		$postStatusQuery = 'all' != $status && !empty($status)
+			? "AND p.post_status = '{$status}'"
+			: '';
+		$key = Str::prefix('_', $key);
+		$values = $this->db->get_col("
             SELECT DISTINCT m.meta_value
             FROM {$this->db->postmeta} m
             LEFT JOIN {$this->db->posts} p ON p.ID = m.post_id
@@ -188,87 +188,87 @@ 
             GROUP BY p.ID -- remove duplicate meta_value entries
             ORDER BY m.meta_id ASC -- sort by oldest meta_value
         ");
-        sort($values);
-        return $values;
-    }
+		sort($values);
+		return $values;
+	}
 
-    /**
-     * @param string $and
-     * @return string
-     */
-    protected function getAndForCounts(array $args, $and = '')
-    {
-        $postIds = implode(',', array_filter(Arr::get($args, 'post_ids', [])));
-        $termIds = implode(',', array_filter(Arr::get($args, 'term_ids', [])));
-        if (!empty($args['type'])) {
-            $and .= "AND m2.meta_value = '{$args['type']}' ";
-        }
-        if ($postIds) {
-            $and .= "AND m3.meta_key = '_assigned_to' AND m3.meta_value IN ({$postIds}) ";
-        }
-        if ($termIds) {
-            $and .= "AND tr.term_taxonomy_id IN ({$termIds}) ";
-        }
-        return glsr()->filter('query/and-for-counts', $and);
-    }
+	/**
+	 * @param string $and
+	 * @return string
+	 */
+	protected function getAndForCounts(array $args, $and = '')
+	{
+		$postIds = implode(',', array_filter(Arr::get($args, 'post_ids', [])));
+		$termIds = implode(',', array_filter(Arr::get($args, 'term_ids', [])));
+		if (!empty($args['type'])) {
+			$and .= "AND m2.meta_value = '{$args['type']}' ";
+		}
+		if ($postIds) {
+			$and .= "AND m3.meta_key = '_assigned_to' AND m3.meta_value IN ({$postIds}) ";
+		}
+		if ($termIds) {
+			$and .= "AND tr.term_taxonomy_id IN ({$termIds}) ";
+		}
+		return glsr()->filter('query/and-for-counts', $and);
+	}
 
-    /**
-     * @param string $and
-     * @return string
-     */
-    protected function getAndForRatings(array $args, $and = '')
-    {
-        $assignedQueries = [];
-        if ($postIds = Arr::consolidate(Arr::get($args, 'post_ids', []))) {
-            $postIds = implode(',', array_filter($postIds));
-            $assignedQueries[] = "(ap.post_id IN ({$postIds}) AND ap.is_published = 1)";
-        }
-        if ($termIds = Arr::consolidate(Arr::get($args, 'term_ids', []))) {
-            $termIds = implode(',', array_filter($termIds));
-            $assignedQueries[] = "at.term_id IN ({$termIds})";
-        }
-        if ($rating = Helper::castToInt(Arr::get($args, 'rating'))) {
-            ++$rating;
-            $and .= "AND r.rating < {$rating} ";
-        }
-        if ($type = Arr::get($args, 'type')) {
-            $and .= "AND r.type = '{$type}' ";
-        }
-        if ($assignedQuery = implode(' OR ', $assignedQueries)) {
-            $and .= "AND ($assignedQuery) ";
-        }
-        return glsr()->filter('query/and-for-ratings', $and);
-    }
+	/**
+	 * @param string $and
+	 * @return string
+	 */
+	protected function getAndForRatings(array $args, $and = '')
+	{
+		$assignedQueries = [];
+		if ($postIds = Arr::consolidate(Arr::get($args, 'post_ids', []))) {
+			$postIds = implode(',', array_filter($postIds));
+			$assignedQueries[] = "(ap.post_id IN ({$postIds}) AND ap.is_published = 1)";
+		}
+		if ($termIds = Arr::consolidate(Arr::get($args, 'term_ids', []))) {
+			$termIds = implode(',', array_filter($termIds));
+			$assignedQueries[] = "at.term_id IN ({$termIds})";
+		}
+		if ($rating = Helper::castToInt(Arr::get($args, 'rating'))) {
+			++$rating;
+			$and .= "AND r.rating < {$rating} ";
+		}
+		if ($type = Arr::get($args, 'type')) {
+			$and .= "AND r.type = '{$type}' ";
+		}
+		if ($assignedQuery = implode(' OR ', $assignedQueries)) {
+			$and .= "AND ($assignedQuery) ";
+		}
+		return glsr()->filter('query/and-for-ratings', $and);
+	}
 
-    /**
-     * @param string $innerJoin
-     * @return string
-     */
-    protected function getInnerJoinForCounts(array $args, $innerJoin = '')
-    {
-        if (!empty(Arr::get($args, 'post_ids'))) {
-            $innerJoin .= "INNER JOIN {$this->db->postmeta} AS m3 ON p.ID = m3.post_id ";
-        }
-        if (!empty(Arr::get($args, 'term_ids'))) {
-            $innerJoin .= "INNER JOIN {$this->db->term_relationships} AS tr ON p.ID = tr.object_id ";
-        }
-        return glsr()->filter('query/inner-join-for-counts', $innerJoin);
-    }
+	/**
+	 * @param string $innerJoin
+	 * @return string
+	 */
+	protected function getInnerJoinForCounts(array $args, $innerJoin = '')
+	{
+		if (!empty(Arr::get($args, 'post_ids'))) {
+			$innerJoin .= "INNER JOIN {$this->db->postmeta} AS m3 ON p.ID = m3.post_id ";
+		}
+		if (!empty(Arr::get($args, 'term_ids'))) {
+			$innerJoin .= "INNER JOIN {$this->db->term_relationships} AS tr ON p.ID = tr.object_id ";
+		}
+		return glsr()->filter('query/inner-join-for-counts', $innerJoin);
+	}
 
-    /**
-     * @param string $innerJoin
-     * @return string
-     */
-    protected function getInnerJoinForRatings(array $args, $innerJoin = '')
-    {
-        if (Arr::consolidate(Arr::get($args, 'post_ids', []))) {
-            $table = glsr(SqlSchema::class)->table('assigned_posts');
-            $innerJoin .= "INNER JOIN {$table} AS ap ON r.ID = ap.rating_id ";
-        }
-        if (Arr::consolidate(Arr::get($args, 'term_ids', []))) {
-            $table = glsr(SqlSchema::class)->table('assigned_terms');
-            $innerJoin .= "INNER JOIN {$table} AS at ON r.ID = at.rating_id ";
-        }
-        return glsr()->filter('query/inner-join-for-ratings', $innerJoin);
-    }
+	/**
+	 * @param string $innerJoin
+	 * @return string
+	 */
+	protected function getInnerJoinForRatings(array $args, $innerJoin = '')
+	{
+		if (Arr::consolidate(Arr::get($args, 'post_ids', []))) {
+			$table = glsr(SqlSchema::class)->table('assigned_posts');
+			$innerJoin .= "INNER JOIN {$table} AS ap ON r.ID = ap.rating_id ";
+		}
+		if (Arr::consolidate(Arr::get($args, 'term_ids', []))) {
+			$table = glsr(SqlSchema::class)->table('assigned_terms');
+			$innerJoin .= "INNER JOIN {$table} AS at ON r.ID = at.rating_id ";
+		}
+		return glsr()->filter('query/inner-join-for-ratings', $innerJoin);
+	}
 }

Spacing +64 added lines, -64 removed lines

@@ -25,11 +25,11 @@ 
      */
     public function deletePostCountMetaKeys()
     {
-        return $this->db->query("
+        return $this->db->query( "
             DELETE
             FROM {$this->db->postmeta}
             WHERE meta_key LIKE '_glsr_%'
-        ");
+        " );
     }
 
     /**
@@ -37,46 +37,46 @@ 
      */
     public function deleteTermCountMetaKeys()
     {
-        return $this->db->query("
+        return $this->db->query( "
             DELETE
             FROM {$this->db->termmeta}
             WHERE meta_key LIKE '_glsr_%'
-        ");
+        " );
     }
 
     /**
      * @param string $metaReviewId
      * @return int
      */
-    public function getPostIdFromReviewId($metaReviewId)
+    public function getPostIdFromReviewId( $metaReviewId )
     {
-        $postId = $this->db->get_var("
+        $postId = $this->db->get_var( "
             SELECT p.ID
             FROM {$this->db->posts} AS p
             INNER JOIN {$this->db->postmeta} AS m ON p.ID = m.post_id
             WHERE p.post_type = '{$this->postType}'
             AND m.meta_key = '_review_id'
             AND m.meta_value = '{$metaReviewId}'
-        ");
-        return intval($postId);
+        " );
+        return intval( $postId );
     }
 
     /**
      * @return array
      */
-    public function getRatings(array $args)
+    public function getRatings( array $args )
     {
         // get types
         // get for each type
-        $table = glsr(SqlSchema::class)->table('ratings');
-        return (array) $this->db->get_results("
+        $table = glsr( SqlSchema::class )->table( 'ratings' );
+        return (array)$this->db->get_results( "
             SELECT r.rating AS rating, COUNT(r.rating) AS count
             FROM {$table} AS r
-            {$this->getInnerJoinForRatings($args)}
+            {$this->getInnerJoinForRatings( $args )}
             WHERE r.is_approved = 1
-            {$this->getAndForRatings($args)}
+            {$this->getAndForRatings( $args )}
             GROUP BY rating
-        ");
+        " );
     }
 
     /**
@@ -84,23 +84,23 @@ 
      * @param int $limit
      * @return array
      */
-    public function getReviewCounts(array $args, $lastPostId = 0, $limit = 500)
+    public function getReviewCounts( array $args, $lastPostId = 0, $limit = 500 )
     {
-        return (array) $this->db->get_results("
+        return (array)$this->db->get_results( "
             SELECT DISTINCT p.ID, m1.meta_value AS rating, m2.meta_value AS type
             FROM {$this->db->posts} AS p
             INNER JOIN {$this->db->postmeta} AS m1 ON p.ID = m1.post_id
             INNER JOIN {$this->db->postmeta} AS m2 ON p.ID = m2.post_id
-            {$this->getInnerJoinForCounts($args)}
+            {$this->getInnerJoinForCounts( $args )}
             WHERE p.ID > {$lastPostId}
             AND p.post_status = 'publish'
             AND p.post_type = '{$this->postType}'
             AND m1.meta_key = '_rating'
             AND m2.meta_key = '_review_type'
-            {$this->getAndForCounts($args)}
+            {$this->getAndForCounts( $args )}
             ORDER By p.ID ASC
             LIMIT {$limit}
-        ");
+        " );
     }
 
     /**
@@ -108,17 +108,17 @@ 
      * @param string $metaKey
      * @return array
      */
-    public function getReviewCountsFor($metaKey)
+    public function getReviewCountsFor( $metaKey )
     {
-        $metaKey = Str::prefix('_', $metaKey);
-        return (array) $this->db->get_results("
+        $metaKey = Str::prefix( '_', $metaKey );
+        return (array)$this->db->get_results( "
             SELECT DISTINCT m.meta_value AS name, COUNT(*) num_posts
             FROM {$this->db->posts} AS p
             INNER JOIN {$this->db->postmeta} AS m ON p.ID = m.post_id
             WHERE p.post_type = '{$this->postType}'
             AND m.meta_key = '{$metaKey}'
             GROUP BY name
-        ");
+        " );
     }
 
     /**
@@ -126,9 +126,9 @@ 
      * @param string $reviewType
      * @return array
      */
-    public function getReviewIdsByType($reviewType)
+    public function getReviewIdsByType( $reviewType )
     {
-        $results = $this->db->get_col("
+        $results = $this->db->get_col( "
             SELECT DISTINCT m1.meta_value AS review_id
             FROM {$this->db->posts} AS p
             INNER JOIN {$this->db->postmeta} AS m1 ON p.ID = m1.post_id
@@ -137,8 +137,8 @@ 
             AND m1.meta_key = '_review_id'
             AND m2.meta_key = '_review_type'
             AND m2.meta_value = '{$reviewType}'
-        ");
-        return array_keys(array_flip($results));
+        " );
+        return array_keys( array_flip( $results ) );
     }
 
     /**
@@ -146,12 +146,12 @@ 
      * @param int $limit
      * @return array
      */
-    public function getReviewRatingsFromIds(array $postIds, $greaterThanId = 0, $limit = 100)
+    public function getReviewRatingsFromIds( array $postIds, $greaterThanId = 0, $limit = 100 )
     {
-        sort($postIds);
-        $postIds = array_slice($postIds, intval(array_search($greaterThanId, $postIds)), $limit);
-        $postIds = implode(',', $postIds);
-        return (array) $this->db->get_results("
+        sort( $postIds );
+        $postIds = array_slice( $postIds, intval( array_search( $greaterThanId, $postIds ) ), $limit );
+        $postIds = implode( ',', $postIds );
+        return (array)$this->db->get_results( "
             SELECT p.ID, m.meta_value AS rating
             FROM {$this->db->posts} AS p
             INNER JOIN {$this->db->postmeta} AS m ON p.ID = m.post_id
@@ -163,7 +163,7 @@ 
             GROUP BY p.ID
             ORDER By p.ID ASC
             LIMIT {$limit}
-        ");
+        " );
     }
 
     /**
@@ -171,13 +171,13 @@ 
      * @param string $status
      * @return array
      */
-    public function getReviewsMeta($key, $status = 'publish')
+    public function getReviewsMeta( $key, $status = 'publish' )
     {
         $postStatusQuery = 'all' != $status && !empty($status)
             ? "AND p.post_status = '{$status}'"
             : '';
-        $key = Str::prefix('_', $key);
-        $values = $this->db->get_col("
+        $key = Str::prefix( '_', $key );
+        $values = $this->db->get_col( "
             SELECT DISTINCT m.meta_value
             FROM {$this->db->postmeta} m
             LEFT JOIN {$this->db->posts} p ON p.ID = m.post_id
@@ -187,8 +187,8 @@ 
             $postStatusQuery
             GROUP BY p.ID -- remove duplicate meta_value entries
             ORDER BY m.meta_id ASC -- sort by oldest meta_value
-        ");
-        sort($values);
+        " );
+        sort( $values );
         return $values;
     }
 
@@ -196,79 +196,79 @@ 
      * @param string $and
      * @return string
      */
-    protected function getAndForCounts(array $args, $and = '')
+    protected function getAndForCounts( array $args, $and = '' )
     {
-        $postIds = implode(',', array_filter(Arr::get($args, 'post_ids', [])));
-        $termIds = implode(',', array_filter(Arr::get($args, 'term_ids', [])));
-        if (!empty($args['type'])) {
+        $postIds = implode( ',', array_filter( Arr::get( $args, 'post_ids', [] ) ) );
+        $termIds = implode( ',', array_filter( Arr::get( $args, 'term_ids', [] ) ) );
+        if( !empty($args['type']) ) {
             $and .= "AND m2.meta_value = '{$args['type']}' ";
         }
-        if ($postIds) {
+        if( $postIds ) {
             $and .= "AND m3.meta_key = '_assigned_to' AND m3.meta_value IN ({$postIds}) ";
         }
-        if ($termIds) {
+        if( $termIds ) {
             $and .= "AND tr.term_taxonomy_id IN ({$termIds}) ";
         }
-        return glsr()->filter('query/and-for-counts', $and);
+        return glsr()->filter( 'query/and-for-counts', $and );
     }
 
     /**
      * @param string $and
      * @return string
      */
-    protected function getAndForRatings(array $args, $and = '')
+    protected function getAndForRatings( array $args, $and = '' )
     {
         $assignedQueries = [];
-        if ($postIds = Arr::consolidate(Arr::get($args, 'post_ids', []))) {
-            $postIds = implode(',', array_filter($postIds));
+        if( $postIds = Arr::consolidate( Arr::get( $args, 'post_ids', [] ) ) ) {
+            $postIds = implode( ',', array_filter( $postIds ) );
             $assignedQueries[] = "(ap.post_id IN ({$postIds}) AND ap.is_published = 1)";
         }
-        if ($termIds = Arr::consolidate(Arr::get($args, 'term_ids', []))) {
-            $termIds = implode(',', array_filter($termIds));
+        if( $termIds = Arr::consolidate( Arr::get( $args, 'term_ids', [] ) ) ) {
+            $termIds = implode( ',', array_filter( $termIds ) );
             $assignedQueries[] = "at.term_id IN ({$termIds})";
         }
-        if ($rating = Helper::castToInt(Arr::get($args, 'rating'))) {
+        if( $rating = Helper::castToInt( Arr::get( $args, 'rating' ) ) ) {
             ++$rating;
             $and .= "AND r.rating < {$rating} ";
         }
-        if ($type = Arr::get($args, 'type')) {
+        if( $type = Arr::get( $args, 'type' ) ) {
             $and .= "AND r.type = '{$type}' ";
         }
-        if ($assignedQuery = implode(' OR ', $assignedQueries)) {
+        if( $assignedQuery = implode( ' OR ', $assignedQueries ) ) {
             $and .= "AND ($assignedQuery) ";
         }
-        return glsr()->filter('query/and-for-ratings', $and);
+        return glsr()->filter( 'query/and-for-ratings', $and );
     }
 
     /**
      * @param string $innerJoin
      * @return string
      */
-    protected function getInnerJoinForCounts(array $args, $innerJoin = '')
+    protected function getInnerJoinForCounts( array $args, $innerJoin = '' )
     {
-        if (!empty(Arr::get($args, 'post_ids'))) {
+        if( !empty(Arr::get( $args, 'post_ids' )) ) {
             $innerJoin .= "INNER JOIN {$this->db->postmeta} AS m3 ON p.ID = m3.post_id ";
         }
-        if (!empty(Arr::get($args, 'term_ids'))) {
+        if( !empty(Arr::get( $args, 'term_ids' )) ) {
             $innerJoin .= "INNER JOIN {$this->db->term_relationships} AS tr ON p.ID = tr.object_id ";
         }
-        return glsr()->filter('query/inner-join-for-counts', $innerJoin);
+        return glsr()->filter( 'query/inner-join-for-counts', $innerJoin );
     }
 
     /**
      * @param string $innerJoin
      * @return string
      */
-    protected function getInnerJoinForRatings(array $args, $innerJoin = '')
+    protected function getInnerJoinForRatings( array $args, $innerJoin = '' )
     {
-        if (Arr::consolidate(Arr::get($args, 'post_ids', []))) {
-            $table = glsr(SqlSchema::class)->table('assigned_posts');
+        if( Arr::consolidate( Arr::get( $args, 'post_ids', [] ) ) ) {
+            $table = glsr( SqlSchema::class )->table( 'assigned_posts' );
             $innerJoin .= "INNER JOIN {$table} AS ap ON r.ID = ap.rating_id ";
         }
-        if (Arr::consolidate(Arr::get($args, 'term_ids', []))) {
-            $table = glsr(SqlSchema::class)->table('assigned_terms');
+        if( Arr::consolidate( Arr::get( $args, 'term_ids', [] ) ) ) {
+            $table = glsr( SqlSchema::class )->table( 'assigned_terms' );
             $innerJoin .= "INNER JOIN {$table} AS at ON r.ID = at.rating_id ";
         }
-        return glsr()->filter('query/inner-join-for-ratings', $innerJoin);
+        return glsr()->filter( 'query/inner-join-for-ratings', $innerJoin );
     }
 }

plugin/Database/TermCountsManager.php

Indentation +82 added lines, -82 removed lines

@@ -9,93 +9,93 @@
 
 class TermCountsManager
 {
-    /**
-     * @var CountsManager
-     */
-    protected $manager;
+	/**
+	 * @var CountsManager
+	 */
+	protected $manager;
 
-    public function __construct()
-    {
-        $this->manager = glsr(CountsManager::class);
-    }
+	public function __construct()
+	{
+		$this->manager = glsr(CountsManager::class);
+	}
 
-    /**
-     * @param int $termTaxonomyId
-     * @return array
-     */
-    public function build($termTaxonomyId)
-    {
-        return $this->manager->buildCounts([
-            'term_ids' => [$termTaxonomyId],
-        ]);
-    }
+	/**
+	 * @param int $termTaxonomyId
+	 * @return array
+	 */
+	public function build($termTaxonomyId)
+	{
+		return $this->manager->buildCounts([
+			'term_ids' => [$termTaxonomyId],
+		]);
+	}
 
-    /**
-     * @return void
-     */
-    public function decrease(Review $review)
-    {
-        foreach ($review->term_ids as $termId) {
-            if (empty($counts = $this->get($termId))) {
-                continue;
-            }
-            $this->update($termId,
-                $this->manager->decreaseRating($counts, $review->review_type, $review->rating)
-            );
-        }
-    }
+	/**
+	 * @return void
+	 */
+	public function decrease(Review $review)
+	{
+		foreach ($review->term_ids as $termId) {
+			if (empty($counts = $this->get($termId))) {
+				continue;
+			}
+			$this->update($termId,
+				$this->manager->decreaseRating($counts, $review->review_type, $review->rating)
+			);
+		}
+	}
 
-    /**
-     * @param int $termId
-     * @return array
-     */
-    public function get($termId)
-    {
-        return array_filter((array) get_term_meta($termId, CountsManager::META_COUNT, true));
-    }
+	/**
+	 * @param int $termId
+	 * @return array
+	 */
+	public function get($termId)
+	{
+		return array_filter((array) get_term_meta($termId, CountsManager::META_COUNT, true));
+	}
 
-    /**
-     * @return void
-     */
-    public function increase(Review $review)
-    {
-        $terms = glsr(ReviewManager::class)->normalizeTerms(implode(',', $review->term_ids));
-        foreach ($terms as $term) {
-            $counts = $this->get($term['term_id']);
-            $counts = empty($counts)
-                ? $this->build($term['term_taxonomy_id'])
-                : $this->manager->increaseRating($counts, $review->review_type, $review->rating);
-            $this->update($term['term_id'], $counts);
-        }
-    }
+	/**
+	 * @return void
+	 */
+	public function increase(Review $review)
+	{
+		$terms = glsr(ReviewManager::class)->normalizeTerms(implode(',', $review->term_ids));
+		foreach ($terms as $term) {
+			$counts = $this->get($term['term_id']);
+			$counts = empty($counts)
+				? $this->build($term['term_taxonomy_id'])
+				: $this->manager->increaseRating($counts, $review->review_type, $review->rating);
+			$this->update($term['term_id'], $counts);
+		}
+	}
 
-    /**
-     * @param int $termId
-     * @return void
-     */
-    public function update($termId, array $reviewCounts)
-    {
-        $term = get_term($termId, Application::TAXONOMY);
-        if (!isset($term->term_id)) {
-            return;
-        }
-        $ratingCounts = $this->manager->flatten($reviewCounts);
-        update_term_meta($termId, CountsManager::META_COUNT, $reviewCounts);
-        update_term_meta($termId, CountsManager::META_AVERAGE, glsr(Rating::class)->average($ratingCounts));
-        update_term_meta($termId, CountsManager::META_RANKING, glsr(Rating::class)->ranking($ratingCounts));
-    }
+	/**
+	 * @param int $termId
+	 * @return void
+	 */
+	public function update($termId, array $reviewCounts)
+	{
+		$term = get_term($termId, Application::TAXONOMY);
+		if (!isset($term->term_id)) {
+			return;
+		}
+		$ratingCounts = $this->manager->flatten($reviewCounts);
+		update_term_meta($termId, CountsManager::META_COUNT, $reviewCounts);
+		update_term_meta($termId, CountsManager::META_AVERAGE, glsr(Rating::class)->average($ratingCounts));
+		update_term_meta($termId, CountsManager::META_RANKING, glsr(Rating::class)->ranking($ratingCounts));
+	}
 
-    /**
-     * @return void
-     */
-    public function updateAll()
-    {
-        // glsr(SqlQueries::class)->deleteTermCountMetaKeys(); // @todo test this with SiteGround for race conditions
-        $terms = glsr(Database::class)->getTerms([
-            'fields' => 'all',
-        ]);
-        foreach ($terms as $term) {
-            $this->update($term->term_id, $this->build($term->term_taxonomy_id));
-        }
-    }
+	/**
+	 * @return void
+	 */
+	public function updateAll()
+	{
+		// glsr(SqlQueries::class)->deleteTermCountMetaKeys(); // @todo test this with SiteGround for race conditions
+		$terms = glsr(Database::class)->getTerms([
+			'fields' => 'all',
+		]);
+		foreach ($terms as $term) {
+			$this->update($term->term_id, $this->build($term->term_taxonomy_id));
+		}
+	}
 }

Spacing +29 added lines, -29 removed lines

@@ -16,31 +16,31 @@ 
 
     public function __construct()
     {
-        $this->manager = glsr(CountsManager::class);
+        $this->manager = glsr( CountsManager::class );
     }
 
     /**
      * @param int $termTaxonomyId
      * @return array
      */
-    public function build($termTaxonomyId)
+    public function build( $termTaxonomyId )
     {
-        return $this->manager->buildCounts([
+        return $this->manager->buildCounts( [
             'term_ids' => [$termTaxonomyId],
-        ]);
+        ] );
     }
 
     /**
      * @return void
      */
-    public function decrease(Review $review)
+    public function decrease( Review $review )
     {
-        foreach ($review->term_ids as $termId) {
-            if (empty($counts = $this->get($termId))) {
+        foreach( $review->term_ids as $termId ) {
+            if( empty($counts = $this->get( $termId )) ) {
                 continue;
             }
-            $this->update($termId,
-                $this->manager->decreaseRating($counts, $review->review_type, $review->rating)
+            $this->update( $termId,
+                $this->manager->decreaseRating( $counts, $review->review_type, $review->rating )
             );
         }
     }
@@ -49,23 +49,23 @@ 
      * @param int $termId
      * @return array
      */
-    public function get($termId)
+    public function get( $termId )
     {
-        return array_filter((array) get_term_meta($termId, CountsManager::META_COUNT, true));
+        return array_filter( (array)get_term_meta( $termId, CountsManager::META_COUNT, true ) );
     }
 
     /**
      * @return void
      */
-    public function increase(Review $review)
+    public function increase( Review $review )
     {
-        $terms = glsr(ReviewManager::class)->normalizeTerms(implode(',', $review->term_ids));
-        foreach ($terms as $term) {
-            $counts = $this->get($term['term_id']);
+        $terms = glsr( ReviewManager::class )->normalizeTerms( implode( ',', $review->term_ids ) );
+        foreach( $terms as $term ) {
+            $counts = $this->get( $term['term_id'] );
             $counts = empty($counts)
-                ? $this->build($term['term_taxonomy_id'])
-                : $this->manager->increaseRating($counts, $review->review_type, $review->rating);
-            $this->update($term['term_id'], $counts);
+                ? $this->build( $term['term_taxonomy_id'] )
+                : $this->manager->increaseRating( $counts, $review->review_type, $review->rating );
+            $this->update( $term['term_id'], $counts );
         }
     }
 
@@ -73,16 +73,16 @@ 
      * @param int $termId
      * @return void
      */
-    public function update($termId, array $reviewCounts)
+    public function update( $termId, array $reviewCounts )
     {
-        $term = get_term($termId, Application::TAXONOMY);
-        if (!isset($term->term_id)) {
+        $term = get_term( $termId, Application::TAXONOMY );
+        if( !isset($term->term_id) ) {
             return;
         }
-        $ratingCounts = $this->manager->flatten($reviewCounts);
-        update_term_meta($termId, CountsManager::META_COUNT, $reviewCounts);
-        update_term_meta($termId, CountsManager::META_AVERAGE, glsr(Rating::class)->average($ratingCounts));
-        update_term_meta($termId, CountsManager::META_RANKING, glsr(Rating::class)->ranking($ratingCounts));
+        $ratingCounts = $this->manager->flatten( $reviewCounts );
+        update_term_meta( $termId, CountsManager::META_COUNT, $reviewCounts );
+        update_term_meta( $termId, CountsManager::META_AVERAGE, glsr( Rating::class )->average( $ratingCounts ) );
+        update_term_meta( $termId, CountsManager::META_RANKING, glsr( Rating::class )->ranking( $ratingCounts ) );
     }
 
     /**
@@ -91,11 +91,11 @@ 
     public function updateAll()
     {
         // glsr(SqlQueries::class)->deleteTermCountMetaKeys(); // @todo test this with SiteGround for race conditions
-        $terms = glsr(Database::class)->getTerms([
+        $terms = glsr( Database::class )->getTerms( [
             'fields' => 'all',
-        ]);
-        foreach ($terms as $term) {
-            $this->update($term->term_id, $this->build($term->term_taxonomy_id));
+        ] );
+        foreach( $terms as $term ) {
+            $this->update( $term->term_id, $this->build( $term->term_taxonomy_id ) );
         }
     }
 }

plugin/Database/PostCountsManager.php

Indentation +74 added lines, -74 removed lines

@@ -7,85 +7,85 @@
 
 class PostCountsManager
 {
-    /**
-     * @var CountsManager
-     */
-    protected $manager;
+	/**
+	 * @var CountsManager
+	 */
+	protected $manager;
 
-    public function __construct()
-    {
-        $this->manager = glsr(CountsManager::class);
-    }
+	public function __construct()
+	{
+		$this->manager = glsr(CountsManager::class);
+	}
 
-    /**
-     * @param int $postId
-     * @return array
-     */
-    public function build($postId)
-    {
-        return $this->manager->buildCounts([
-            'post_ids' => [$postId],
-        ]);
-    }
+	/**
+	 * @param int $postId
+	 * @return array
+	 */
+	public function build($postId)
+	{
+		return $this->manager->buildCounts([
+			'post_ids' => [$postId],
+		]);
+	}
 
-    /**
-     * @return void
-     */
-    public function decrease(Review $review)
-    {
-        if (empty($counts = $this->get($review->assigned_to))) {
-            return;
-        }
-        $this->update($review->assigned_to,
-            $this->manager->decreaseRating($counts, $review->review_type, $review->rating)
-        );
-    }
+	/**
+	 * @return void
+	 */
+	public function decrease(Review $review)
+	{
+		if (empty($counts = $this->get($review->assigned_to))) {
+			return;
+		}
+		$this->update($review->assigned_to,
+			$this->manager->decreaseRating($counts, $review->review_type, $review->rating)
+		);
+	}
 
-    /**
-     * @param int $postId
-     * @return array
-     */
-    public function get($postId)
-    {
-        return array_filter((array) get_post_meta($postId, CountsManager::META_COUNT, true));
-    }
+	/**
+	 * @param int $postId
+	 * @return array
+	 */
+	public function get($postId)
+	{
+		return array_filter((array) get_post_meta($postId, CountsManager::META_COUNT, true));
+	}
 
-    /**
-     * @return void
-     */
-    public function increase(Review $review)
-    {
-        if (!get_post($review->assigned_to) instanceof \WP_Post) {
-            return;
-        }
-        $counts = $this->get($review->assigned_to);
-        $counts = empty($counts)
-            ? $this->build($review->assigned_to)
-            : $this->manager->increaseRating($counts, $review->review_type, $review->rating);
-        $this->update($review->assigned_to, $counts);
-    }
+	/**
+	 * @return void
+	 */
+	public function increase(Review $review)
+	{
+		if (!get_post($review->assigned_to) instanceof \WP_Post) {
+			return;
+		}
+		$counts = $this->get($review->assigned_to);
+		$counts = empty($counts)
+			? $this->build($review->assigned_to)
+			: $this->manager->increaseRating($counts, $review->review_type, $review->rating);
+		$this->update($review->assigned_to, $counts);
+	}
 
-    /**
-     * @param int $postId
-     * @return void
-     */
-    public function update($postId, array $reviewCounts)
-    {
-        $ratingCounts = $this->manager->flatten($reviewCounts);
-        update_post_meta($postId, CountsManager::META_COUNT, $reviewCounts);
-        update_post_meta($postId, CountsManager::META_AVERAGE, glsr(Rating::class)->average($ratingCounts));
-        update_post_meta($postId, CountsManager::META_RANKING, glsr(Rating::class)->ranking($ratingCounts));
-    }
+	/**
+	 * @param int $postId
+	 * @return void
+	 */
+	public function update($postId, array $reviewCounts)
+	{
+		$ratingCounts = $this->manager->flatten($reviewCounts);
+		update_post_meta($postId, CountsManager::META_COUNT, $reviewCounts);
+		update_post_meta($postId, CountsManager::META_AVERAGE, glsr(Rating::class)->average($ratingCounts));
+		update_post_meta($postId, CountsManager::META_RANKING, glsr(Rating::class)->ranking($ratingCounts));
+	}
 
-    /**
-     * @return void
-     */
-    public function updateAll()
-    {
-        glsr(SqlQueries::class)->deletePostCountMetaKeys(); // @todo test this with SiteGround for race conditions
-        $postIds = glsr(SqlQueries::class)->getReviewsMeta('assigned_to');
-        foreach ($postIds as $postId) {
-            $this->update($postId, $this->build($postId));
-        }
-    }
+	/**
+	 * @return void
+	 */
+	public function updateAll()
+	{
+		glsr(SqlQueries::class)->deletePostCountMetaKeys(); // @todo test this with SiteGround for race conditions
+		$postIds = glsr(SqlQueries::class)->getReviewsMeta('assigned_to');
+		foreach ($postIds as $postId) {
+			$this->update($postId, $this->build($postId));
+		}
+	}
 }

Spacing +25 added lines, -25 removed lines

@@ -14,30 +14,30 @@ 
 
     public function __construct()
     {
-        $this->manager = glsr(CountsManager::class);
+        $this->manager = glsr( CountsManager::class );
     }
 
     /**
      * @param int $postId
      * @return array
      */
-    public function build($postId)
+    public function build( $postId )
     {
-        return $this->manager->buildCounts([
+        return $this->manager->buildCounts( [
             'post_ids' => [$postId],
-        ]);
+        ] );
     }
 
     /**
      * @return void
      */
-    public function decrease(Review $review)
+    public function decrease( Review $review )
     {
-        if (empty($counts = $this->get($review->assigned_to))) {
+        if( empty($counts = $this->get( $review->assigned_to )) ) {
             return;
         }
-        $this->update($review->assigned_to,
-            $this->manager->decreaseRating($counts, $review->review_type, $review->rating)
+        $this->update( $review->assigned_to,
+            $this->manager->decreaseRating( $counts, $review->review_type, $review->rating )
         );
     }
 
@@ -45,36 +45,36 @@ 
      * @param int $postId
      * @return array
      */
-    public function get($postId)
+    public function get( $postId )
     {
-        return array_filter((array) get_post_meta($postId, CountsManager::META_COUNT, true));
+        return array_filter( (array)get_post_meta( $postId, CountsManager::META_COUNT, true ) );
     }
 
     /**
      * @return void
      */
-    public function increase(Review $review)
+    public function increase( Review $review )
     {
-        if (!get_post($review->assigned_to) instanceof \WP_Post) {
+        if( !get_post( $review->assigned_to ) instanceof \WP_Post ) {
             return;
         }
-        $counts = $this->get($review->assigned_to);
+        $counts = $this->get( $review->assigned_to );
         $counts = empty($counts)
-            ? $this->build($review->assigned_to)
-            : $this->manager->increaseRating($counts, $review->review_type, $review->rating);
-        $this->update($review->assigned_to, $counts);
+            ? $this->build( $review->assigned_to )
+            : $this->manager->increaseRating( $counts, $review->review_type, $review->rating );
+        $this->update( $review->assigned_to, $counts );
     }
 
     /**
      * @param int $postId
      * @return void
      */
-    public function update($postId, array $reviewCounts)
+    public function update( $postId, array $reviewCounts )
     {
-        $ratingCounts = $this->manager->flatten($reviewCounts);
-        update_post_meta($postId, CountsManager::META_COUNT, $reviewCounts);
-        update_post_meta($postId, CountsManager::META_AVERAGE, glsr(Rating::class)->average($ratingCounts));
-        update_post_meta($postId, CountsManager::META_RANKING, glsr(Rating::class)->ranking($ratingCounts));
+        $ratingCounts = $this->manager->flatten( $reviewCounts );
+        update_post_meta( $postId, CountsManager::META_COUNT, $reviewCounts );
+        update_post_meta( $postId, CountsManager::META_AVERAGE, glsr( Rating::class )->average( $ratingCounts ) );
+        update_post_meta( $postId, CountsManager::META_RANKING, glsr( Rating::class )->ranking( $ratingCounts ) );
     }
 
     /**
@@ -82,10 +82,10 @@ 
      */
     public function updateAll()
     {
-        glsr(SqlQueries::class)->deletePostCountMetaKeys(); // @todo test this with SiteGround for race conditions
-        $postIds = glsr(SqlQueries::class)->getReviewsMeta('assigned_to');
-        foreach ($postIds as $postId) {
-            $this->update($postId, $this->build($postId));
+        glsr( SqlQueries::class )->deletePostCountMetaKeys(); // @todo test this with SiteGround for race conditions
+        $postIds = glsr( SqlQueries::class )->getReviewsMeta( 'assigned_to' );
+        foreach( $postIds as $postId ) {
+            $this->update( $postId, $this->build( $postId ) );
         }
     }
 }

plugin/Database/DefaultsManager.php

Indentation +52 added lines, -52 removed lines

@@ -6,60 +6,60 @@
 
 class DefaultsManager
 {
-    /**
-     * @return array
-     */
-    public function defaults()
-    {
-        $settings = $this->settings();
-        $defaults = (array) array_combine(array_keys($settings), wp_list_pluck($settings, 'default'));
-        return wp_parse_args($defaults, [
-            'version' => '',
-            'version_upgraded_from' => '',
-        ]);
-    }
+	/**
+	 * @return array
+	 */
+	public function defaults()
+	{
+		$settings = $this->settings();
+		$defaults = (array) array_combine(array_keys($settings), wp_list_pluck($settings, 'default'));
+		return wp_parse_args($defaults, [
+			'version' => '',
+			'version_upgraded_from' => '',
+		]);
+	}
 
-    /**
-     * @return array
-     */
-    public function get()
-    {
-        return Arr::convertFromDotNotation($this->defaults());
-    }
+	/**
+	 * @return array
+	 */
+	public function get()
+	{
+		return Arr::convertFromDotNotation($this->defaults());
+	}
 
-    /**
-     * @return array
-     */
-    public function set()
-    {
-        $settings = glsr(OptionManager::class)->all();
-        $currentSettings = Arr::removeEmptyValues($settings);
-        $defaultSettings = array_replace_recursive($this->get(), $currentSettings);
-        $updatedSettings = array_replace_recursive($settings, $defaultSettings);
-        update_option(OptionManager::databaseKey(), $updatedSettings);
-        return $defaultSettings;
-    }
+	/**
+	 * @return array
+	 */
+	public function set()
+	{
+		$settings = glsr(OptionManager::class)->all();
+		$currentSettings = Arr::removeEmptyValues($settings);
+		$defaultSettings = array_replace_recursive($this->get(), $currentSettings);
+		$updatedSettings = array_replace_recursive($settings, $defaultSettings);
+		update_option(OptionManager::databaseKey(), $updatedSettings);
+		return $defaultSettings;
+	}
 
-    /**
-     * @return array
-     */
-    public function settings()
-    {
-        $settings = glsr()->filterArray('addon/settings', glsr()->config('settings'));
-        return $this->normalize($settings);
-    }
+	/**
+	 * @return array
+	 */
+	public function settings()
+	{
+		$settings = glsr()->filterArray('addon/settings', glsr()->config('settings'));
+		return $this->normalize($settings);
+	}
 
-    /**
-     * @return array
-     */
-    protected function normalize(array $settings)
-    {
-        array_walk($settings, function (&$setting) {
-            if (isset($setting['default'])) {
-                return;
-            }
-            $setting['default'] = '';
-        });
-        return $settings;
-    }
+	/**
+	 * @return array
+	 */
+	protected function normalize(array $settings)
+	{
+		array_walk($settings, function (&$setting) {
+			if (isset($setting['default'])) {
+				return;
+			}
+			$setting['default'] = '';
+		});
+		return $settings;
+	}
 }

Spacing +14 added lines, -14 removed lines

@@ -12,11 +12,11 @@ 
     public function defaults()
     {
         $settings = $this->settings();
-        $defaults = (array) array_combine(array_keys($settings), wp_list_pluck($settings, 'default'));
-        return wp_parse_args($defaults, [
+        $defaults = (array)array_combine( array_keys( $settings ), wp_list_pluck( $settings, 'default' ) );
+        return wp_parse_args( $defaults, [
             'version' => '',
             'version_upgraded_from' => '',
-        ]);
+        ] );
     }
 
     /**
@@ -24,7 +24,7 @@ 
      */
     public function get()
     {
-        return Arr::convertFromDotNotation($this->defaults());
+        return Arr::convertFromDotNotation( $this->defaults() );
     }
 
     /**
@@ -32,11 +32,11 @@ 
      */
     public function set()
     {
-        $settings = glsr(OptionManager::class)->all();
-        $currentSettings = Arr::removeEmptyValues($settings);
-        $defaultSettings = array_replace_recursive($this->get(), $currentSettings);
-        $updatedSettings = array_replace_recursive($settings, $defaultSettings);
-        update_option(OptionManager::databaseKey(), $updatedSettings);
+        $settings = glsr( OptionManager::class )->all();
+        $currentSettings = Arr::removeEmptyValues( $settings );
+        $defaultSettings = array_replace_recursive( $this->get(), $currentSettings );
+        $updatedSettings = array_replace_recursive( $settings, $defaultSettings );
+        update_option( OptionManager::databaseKey(), $updatedSettings );
         return $defaultSettings;
     }
 
@@ -45,17 +45,17 @@ 
      */
     public function settings()
     {
-        $settings = glsr()->filterArray('addon/settings', glsr()->config('settings'));
-        return $this->normalize($settings);
+        $settings = glsr()->filterArray( 'addon/settings', glsr()->config( 'settings' ) );
+        return $this->normalize( $settings );
     }
 
     /**
      * @return array
      */
-    protected function normalize(array $settings)
+    protected function normalize( array $settings )
     {
-        array_walk($settings, function (&$setting) {
-            if (isset($setting['default'])) {
+        array_walk( $settings, function( &$setting ) {
+            if( isset($setting['default']) ) {
                 return;
             }
             $setting['default'] = '';

plugin/Database/NormalizeQueryArgs.php

Indentation +65 added lines, -65 removed lines

@@ -10,73 +10,73 @@
 
 class NormalizeQueryArgs extends Arguments
 {
-    public $assigned_to;
-    public $category;
-    public $offset;
-    public $order;
-    public $orderby;
-    public $page;
-    public $per_page;
-    public $post__in;
-    public $post__not_in;
-    public $rating;
-    public $type;
-    public $user;
+	public $assigned_to;
+	public $category;
+	public $offset;
+	public $order;
+	public $orderby;
+	public $page;
+	public $per_page;
+	public $post__in;
+	public $post__not_in;
+	public $rating;
+	public $type;
+	public $user;
 
-    public function __construct(array $args = [])
-    {
-        $args = glsr(ReviewsDefaults::class)->merge($args);
-        $args['assigned_to'] = Arr::uniqueInt(Arr::consolidate($args['assigned_to']));
-        $args['category'] = $this->normalizeTermIds($args['category']);
-        $args['offset'] = absint(filter_var($args['offset'], FILTER_SANITIZE_NUMBER_INT));
-        $args['order'] = Str::restrictTo('ASC,DESC,', sanitize_key($args['order']), 'DESC'); // include an empty value
-        $args['orderby'] = $this->normalizeOrderBy($args['orderby']);
-        $args['page'] = absint($args['page']);
-        $args['per_page'] = absint($args['per_page']); // "0" and "-1" = all
-        $args['post__in'] = Arr::uniqueInt(Arr::consolidate($args['post__in']));
-        $args['post__not_in'] = Arr::uniqueInt(Arr::consolidate($args['post__not_in']));
-        $args['rating'] = absint(filter_var($args['rating'], FILTER_SANITIZE_NUMBER_INT));
-        $args['type'] = sanitize_key($args['type']);
-        $args['user'] = $this->normalizeUserIds(Arr::consolidate($args['user']));
-        parent::__construct($args);
-    }
+	public function __construct(array $args = [])
+	{
+		$args = glsr(ReviewsDefaults::class)->merge($args);
+		$args['assigned_to'] = Arr::uniqueInt(Arr::consolidate($args['assigned_to']));
+		$args['category'] = $this->normalizeTermIds($args['category']);
+		$args['offset'] = absint(filter_var($args['offset'], FILTER_SANITIZE_NUMBER_INT));
+		$args['order'] = Str::restrictTo('ASC,DESC,', sanitize_key($args['order']), 'DESC'); // include an empty value
+		$args['orderby'] = $this->normalizeOrderBy($args['orderby']);
+		$args['page'] = absint($args['page']);
+		$args['per_page'] = absint($args['per_page']); // "0" and "-1" = all
+		$args['post__in'] = Arr::uniqueInt(Arr::consolidate($args['post__in']));
+		$args['post__not_in'] = Arr::uniqueInt(Arr::consolidate($args['post__not_in']));
+		$args['rating'] = absint(filter_var($args['rating'], FILTER_SANITIZE_NUMBER_INT));
+		$args['type'] = sanitize_key($args['type']);
+		$args['user'] = $this->normalizeUserIds(Arr::consolidate($args['user']));
+		parent::__construct($args);
+	}
 
-    /**
-     * @return string
-     */
-    protected function normalizeOrderBy($orderBy)
-    {
-        $orderBy = Str::restrictTo('author,comment_count,date,ID,menu_order,none,rand,relevance', $orderBy, 'date');
-        if (in_array($orderBy, ['comment_count', 'ID', 'menu_order'])) {
-            return Str::prefix('p.', $orderBy);
-        }
-        if (in_array($orderBy, ['author', 'date'])) {
-            return Str::prefix('p.post_', $orderBy);
-        }
-        return $orderBy;
-    }
+	/**
+	 * @return string
+	 */
+	protected function normalizeOrderBy($orderBy)
+	{
+		$orderBy = Str::restrictTo('author,comment_count,date,ID,menu_order,none,rand,relevance', $orderBy, 'date');
+		if (in_array($orderBy, ['comment_count', 'ID', 'menu_order'])) {
+			return Str::prefix('p.', $orderBy);
+		}
+		if (in_array($orderBy, ['author', 'date'])) {
+			return Str::prefix('p.post_', $orderBy);
+		}
+		return $orderBy;
+	}
 
-    /**
-     * @param array[]|string $termIds
-     * @return array
-     */
-    public function normalizeTermIds($termIds)
-    {
-        return glsr(ReviewManager::class)->normalizeTermIds($termIds);
-    }
+	/**
+	 * @param array[]|string $termIds
+	 * @return array
+	 */
+	public function normalizeTermIds($termIds)
+	{
+		return glsr(ReviewManager::class)->normalizeTermIds($termIds);
+	}
 
-    /**
-     * @return array
-     */
-    protected function normalizeUserIds(array $users)
-    {
-        $userIds = [];
-        foreach ($users as $userId) {
-            if (!is_numeric($userId)) {
-                $userId = Helper::castToInt(username_exists($userId));
-            }
-            $userIds[] = $userId;
-        }
-        return Arr::uniqueInt($userIds);
-    }
+	/**
+	 * @return array
+	 */
+	protected function normalizeUserIds(array $users)
+	{
+		$userIds = [];
+		foreach ($users as $userId) {
+			if (!is_numeric($userId)) {
+				$userId = Helper::castToInt(username_exists($userId));
+			}
+			$userIds[] = $userId;
+		}
+		return Arr::uniqueInt($userIds);
+	}
 }

Spacing +28 added lines, -28 removed lines

@@ -23,35 +23,35 @@ 
     public $type;
     public $user;
 
-    public function __construct(array $args = [])
+    public function __construct( array $args = [] )
     {
-        $args = glsr(ReviewsDefaults::class)->merge($args);
-        $args['assigned_to'] = Arr::uniqueInt(Arr::consolidate($args['assigned_to']));
-        $args['category'] = $this->normalizeTermIds($args['category']);
-        $args['offset'] = absint(filter_var($args['offset'], FILTER_SANITIZE_NUMBER_INT));
-        $args['order'] = Str::restrictTo('ASC,DESC,', sanitize_key($args['order']), 'DESC'); // include an empty value
-        $args['orderby'] = $this->normalizeOrderBy($args['orderby']);
-        $args['page'] = absint($args['page']);
-        $args['per_page'] = absint($args['per_page']); // "0" and "-1" = all
-        $args['post__in'] = Arr::uniqueInt(Arr::consolidate($args['post__in']));
-        $args['post__not_in'] = Arr::uniqueInt(Arr::consolidate($args['post__not_in']));
-        $args['rating'] = absint(filter_var($args['rating'], FILTER_SANITIZE_NUMBER_INT));
-        $args['type'] = sanitize_key($args['type']);
-        $args['user'] = $this->normalizeUserIds(Arr::consolidate($args['user']));
-        parent::__construct($args);
+        $args = glsr( ReviewsDefaults::class )->merge( $args );
+        $args['assigned_to'] = Arr::uniqueInt( Arr::consolidate( $args['assigned_to'] ) );
+        $args['category'] = $this->normalizeTermIds( $args['category'] );
+        $args['offset'] = absint( filter_var( $args['offset'], FILTER_SANITIZE_NUMBER_INT ) );
+        $args['order'] = Str::restrictTo( 'ASC,DESC,', sanitize_key( $args['order'] ), 'DESC' ); // include an empty value
+        $args['orderby'] = $this->normalizeOrderBy( $args['orderby'] );
+        $args['page'] = absint( $args['page'] );
+        $args['per_page'] = absint( $args['per_page'] ); // "0" and "-1" = all
+        $args['post__in'] = Arr::uniqueInt( Arr::consolidate( $args['post__in'] ) );
+        $args['post__not_in'] = Arr::uniqueInt( Arr::consolidate( $args['post__not_in'] ) );
+        $args['rating'] = absint( filter_var( $args['rating'], FILTER_SANITIZE_NUMBER_INT ) );
+        $args['type'] = sanitize_key( $args['type'] );
+        $args['user'] = $this->normalizeUserIds( Arr::consolidate( $args['user'] ) );
+        parent::__construct( $args );
     }
 
     /**
      * @return string
      */
-    protected function normalizeOrderBy($orderBy)
+    protected function normalizeOrderBy( $orderBy )
     {
-        $orderBy = Str::restrictTo('author,comment_count,date,ID,menu_order,none,rand,relevance', $orderBy, 'date');
-        if (in_array($orderBy, ['comment_count', 'ID', 'menu_order'])) {
-            return Str::prefix('p.', $orderBy);
+        $orderBy = Str::restrictTo( 'author,comment_count,date,ID,menu_order,none,rand,relevance', $orderBy, 'date' );
+        if( in_array( $orderBy, ['comment_count', 'ID', 'menu_order'] ) ) {
+            return Str::prefix( 'p.', $orderBy );
         }
-        if (in_array($orderBy, ['author', 'date'])) {
-            return Str::prefix('p.post_', $orderBy);
+        if( in_array( $orderBy, ['author', 'date'] ) ) {
+            return Str::prefix( 'p.post_', $orderBy );
         }
         return $orderBy;
     }
@@ -60,23 +60,23 @@ 
      * @param array[]|string $termIds
      * @return array
      */
-    public function normalizeTermIds($termIds)
+    public function normalizeTermIds( $termIds )
     {
-        return glsr(ReviewManager::class)->normalizeTermIds($termIds);
+        return glsr( ReviewManager::class )->normalizeTermIds( $termIds );
     }
 
     /**
      * @return array
      */
-    protected function normalizeUserIds(array $users)
+    protected function normalizeUserIds( array $users )
     {
         $userIds = [];
-        foreach ($users as $userId) {
-            if (!is_numeric($userId)) {
-                $userId = Helper::castToInt(username_exists($userId));
+        foreach( $users as $userId ) {
+            if( !is_numeric( $userId ) ) {
+                $userId = Helper::castToInt( username_exists( $userId ) );
             }
             $userIds[] = $userId;
         }
-        return Arr::uniqueInt($userIds);
+        return Arr::uniqueInt( $userIds );
     }
 }

plugin/Database/QueryBuilder.php

Indentation +151 added lines, -151 removed lines

@@ -12,164 +12,164 @@
 
 class QueryBuilder
 {
-    /**
-     * Build a WP_Query meta_query/tax_query.
-     * @return array
-     */
-    public function buildQuery(array $keys = [], array $values = [])
-    {
-        $queries = [];
-        foreach ($keys as $key) {
-            if (!array_key_exists($key, $values)) {
-                continue;
-            }
-            $methodName = Helper::buildMethodName($key, __FUNCTION__);
-            if (!method_exists($this, $methodName)) {
-                continue;
-            }
-            $query = call_user_func([$this, $methodName], $values[$key]);
-            if (is_array($query)) {
-                $queries[] = $query;
-            }
-        }
-        return $queries;
-    }
+	/**
+	 * Build a WP_Query meta_query/tax_query.
+	 * @return array
+	 */
+	public function buildQuery(array $keys = [], array $values = [])
+	{
+		$queries = [];
+		foreach ($keys as $key) {
+			if (!array_key_exists($key, $values)) {
+				continue;
+			}
+			$methodName = Helper::buildMethodName($key, __FUNCTION__);
+			if (!method_exists($this, $methodName)) {
+				continue;
+			}
+			$query = call_user_func([$this, $methodName], $values[$key]);
+			if (is_array($query)) {
+				$queries[] = $query;
+			}
+		}
+		return $queries;
+	}
 
-    /**
-     * @return string
-     */
-    public function buildSqlLines(array $values, array $conditions)
-    {
-        $string = '';
-        $values = array_filter($values);
-        foreach ($conditions as $key => $value) {
-            if (!isset($values[$key])) {
-                continue;
-            }
-            $values[$key] = implode(',', (array) $values[$key]);
-            $string.= Str::contains($value, '%s')
-                ? sprintf($value, strval($values[$key]))
-                : $value;
-        }
-        return $string;
-    }
+	/**
+	 * @return string
+	 */
+	public function buildSqlLines(array $values, array $conditions)
+	{
+		$string = '';
+		$values = array_filter($values);
+		foreach ($conditions as $key => $value) {
+			if (!isset($values[$key])) {
+				continue;
+			}
+			$values[$key] = implode(',', (array) $values[$key]);
+			$string.= Str::contains($value, '%s')
+				? sprintf($value, strval($values[$key]))
+				: $value;
+		}
+		return $string;
+	}
 
-    /**
-     * Build a SQL 'OR' string from an array.
-     * @param string|array $values
-     * @param string $sprintfFormat
-     * @return string
-     */
-    public function buildSqlOr($values, $sprintfFormat)
-    {
-        if (!is_array($values)) {
-            $values = explode(',', $values);
-        }
-        $values = array_filter(array_map('trim', (array) $values));
-        $values = array_map(function ($value) use ($sprintfFormat) {
-            return sprintf($sprintfFormat, $value);
-        }, $values);
-        return implode(' OR ', $values);
-    }
+	/**
+	 * Build a SQL 'OR' string from an array.
+	 * @param string|array $values
+	 * @param string $sprintfFormat
+	 * @return string
+	 */
+	public function buildSqlOr($values, $sprintfFormat)
+	{
+		if (!is_array($values)) {
+			$values = explode(',', $values);
+		}
+		$values = array_filter(array_map('trim', (array) $values));
+		$values = array_map(function ($value) use ($sprintfFormat) {
+			return sprintf($sprintfFormat, $value);
+		}, $values);
+		return implode(' OR ', $values);
+	}
 
-    /**
-     * Get the current page number from the global query.
-     * @param bool $isEnabled
-     * @return int
-     */
-    public function getPaged($isEnabled = true)
-    {
-        return $isEnabled
-            ? max(1, intval(filter_input(INPUT_GET, glsr()->constant('PAGED_QUERY_VAR'))))
-            : 1;
-    }
+	/**
+	 * Get the current page number from the global query.
+	 * @param bool $isEnabled
+	 * @return int
+	 */
+	public function getPaged($isEnabled = true)
+	{
+		return $isEnabled
+			? max(1, intval(filter_input(INPUT_GET, glsr()->constant('PAGED_QUERY_VAR'))))
+			: 1;
+	}
 
-    /**
-     * @param string $value
-     * @return void|array
-     */
-    protected function buildQueryAssignedTo($value)
-    {
-        if (!empty($value)) {
-            $postIds = Arr::convertFromString($value, 'is_numeric');
-            return [
-                'compare' => 'IN',
-                'key' => '_assigned_to',
-                'value' => glsr(Multilingual::class)->getPostIds($postIds),
-            ];
-        }
-    }
+	/**
+	 * @param string $value
+	 * @return void|array
+	 */
+	protected function buildQueryAssignedTo($value)
+	{
+		if (!empty($value)) {
+			$postIds = Arr::convertFromString($value, 'is_numeric');
+			return [
+				'compare' => 'IN',
+				'key' => '_assigned_to',
+				'value' => glsr(Multilingual::class)->getPostIds($postIds),
+			];
+		}
+	}
 
-    /**
-     * @param array $value
-     * @return void|array
-     */
-    protected function buildQueryCategory($value)
-    {
-        if (!empty($value)) {
-            return [
-                'field' => 'term_id',
-                'taxonomy' => Application::TAXONOMY,
-                'terms' => $value,
-            ];
-        }
-    }
+	/**
+	 * @param array $value
+	 * @return void|array
+	 */
+	protected function buildQueryCategory($value)
+	{
+		if (!empty($value)) {
+			return [
+				'field' => 'term_id',
+				'taxonomy' => Application::TAXONOMY,
+				'terms' => $value,
+			];
+		}
+	}
 
-    /**
-     * @param string $value
-     * @return void|array
-     */
-    protected function buildQueryEmail($value)
-    {
-        if (!empty($value)) {
-            return [
-                'key' => '_email',
-                'value' => $value,
-            ];
-        }
-    }
+	/**
+	 * @param string $value
+	 * @return void|array
+	 */
+	protected function buildQueryEmail($value)
+	{
+		if (!empty($value)) {
+			return [
+				'key' => '_email',
+				'value' => $value,
+			];
+		}
+	}
 
-    /**
-     * @param string $value
-     * @return void|array
-     */
-    protected function buildQueryIpAddress($value)
-    {
-        if (!empty($value)) {
-            return [
-                'key' => '_ip_address',
-                'value' => $value,
-            ];
-        }
-    }
+	/**
+	 * @param string $value
+	 * @return void|array
+	 */
+	protected function buildQueryIpAddress($value)
+	{
+		if (!empty($value)) {
+			return [
+				'key' => '_ip_address',
+				'value' => $value,
+			];
+		}
+	}
 
-    /**
-     * @param string $value
-     * @return void|array
-     */
-    protected function buildQueryRating($value)
-    {
-        if (is_numeric($value)
-            && in_array(intval($value), range(1, glsr()->constant('MAX_RATING', Rating::class)))) {
-            return [
-                'compare' => '>=',
-                'key' => '_rating',
-                'value' => $value,
-            ];
-        }
-    }
+	/**
+	 * @param string $value
+	 * @return void|array
+	 */
+	protected function buildQueryRating($value)
+	{
+		if (is_numeric($value)
+			&& in_array(intval($value), range(1, glsr()->constant('MAX_RATING', Rating::class)))) {
+			return [
+				'compare' => '>=',
+				'key' => '_rating',
+				'value' => $value,
+			];
+		}
+	}
 
-    /**
-     * @param string $value
-     * @return void|array
-     */
-    protected function buildQueryType($value)
-    {
-        if (!in_array($value, ['', 'all'])) {
-            return [
-                'key' => '_review_type',
-                'value' => $value,
-            ];
-        }
-    }
+	/**
+	 * @param string $value
+	 * @return void|array
+	 */
+	protected function buildQueryType($value)
+	{
+		if (!in_array($value, ['', 'all'])) {
+			return [
+				'key' => '_review_type',
+				'value' => $value,
+			];
+		}
+	}
 }

Spacing +39 added lines, -39 removed lines

@@ -16,19 +16,19 @@ 
      * Build a WP_Query meta_query/tax_query.
      * @return array
      */
-    public function buildQuery(array $keys = [], array $values = [])
+    public function buildQuery( array $keys = [], array $values = [] )
     {
         $queries = [];
-        foreach ($keys as $key) {
-            if (!array_key_exists($key, $values)) {
+        foreach( $keys as $key ) {
+            if( !array_key_exists( $key, $values ) ) {
                 continue;
             }
-            $methodName = Helper::buildMethodName($key, __FUNCTION__);
-            if (!method_exists($this, $methodName)) {
+            $methodName = Helper::buildMethodName( $key, __FUNCTION__ );
+            if( !method_exists( $this, $methodName ) ) {
                 continue;
             }
-            $query = call_user_func([$this, $methodName], $values[$key]);
-            if (is_array($query)) {
+            $query = call_user_func( [$this, $methodName], $values[$key] );
+            if( is_array( $query ) ) {
                 $queries[] = $query;
             }
         }
@@ -38,17 +38,17 @@ 
     /**
      * @return string
      */
-    public function buildSqlLines(array $values, array $conditions)
+    public function buildSqlLines( array $values, array $conditions )
     {
         $string = '';
-        $values = array_filter($values);
-        foreach ($conditions as $key => $value) {
-            if (!isset($values[$key])) {
+        $values = array_filter( $values );
+        foreach( $conditions as $key => $value ) {
+            if( !isset($values[$key]) ) {
                 continue;
             }
-            $values[$key] = implode(',', (array) $values[$key]);
-            $string.= Str::contains($value, '%s')
-                ? sprintf($value, strval($values[$key]))
+            $values[$key] = implode( ',', (array)$values[$key] );
+            $string .= Str::contains( $value, '%s' )
+                ? sprintf( $value, strval( $values[$key] ) )
                 : $value;
         }
         return $string;
@@ -60,16 +60,16 @@ 
      * @param string $sprintfFormat
      * @return string
      */
-    public function buildSqlOr($values, $sprintfFormat)
+    public function buildSqlOr( $values, $sprintfFormat )
     {
-        if (!is_array($values)) {
-            $values = explode(',', $values);
+        if( !is_array( $values ) ) {
+            $values = explode( ',', $values );
         }
-        $values = array_filter(array_map('trim', (array) $values));
-        $values = array_map(function ($value) use ($sprintfFormat) {
-            return sprintf($sprintfFormat, $value);
-        }, $values);
-        return implode(' OR ', $values);
+        $values = array_filter( array_map( 'trim', (array)$values ) );
+        $values = array_map( function( $value ) use ($sprintfFormat) {
+            return sprintf( $sprintfFormat, $value );
+        }, $values );
+        return implode( ' OR ', $values );
     }
 
     /**
@@ -77,10 +77,10 @@ 
      * @param bool $isEnabled
      * @return int
      */
-    public function getPaged($isEnabled = true)
+    public function getPaged( $isEnabled = true )
     {
         return $isEnabled
-            ? max(1, intval(filter_input(INPUT_GET, glsr()->constant('PAGED_QUERY_VAR'))))
+            ? max( 1, intval( filter_input( INPUT_GET, glsr()->constant( 'PAGED_QUERY_VAR' ) ) ) )
             : 1;
     }
 
@@ -88,14 +88,14 @@ 
      * @param string $value
      * @return void|array
      */
-    protected function buildQueryAssignedTo($value)
+    protected function buildQueryAssignedTo( $value )
     {
-        if (!empty($value)) {
-            $postIds = Arr::convertFromString($value, 'is_numeric');
+        if( !empty($value) ) {
+            $postIds = Arr::convertFromString( $value, 'is_numeric' );
             return [
                 'compare' => 'IN',
                 'key' => '_assigned_to',
-                'value' => glsr(Multilingual::class)->getPostIds($postIds),
+                'value' => glsr( Multilingual::class )->getPostIds( $postIds ),
             ];
         }
     }
@@ -104,9 +104,9 @@ 
      * @param array $value
      * @return void|array
      */
-    protected function buildQueryCategory($value)
+    protected function buildQueryCategory( $value )
     {
-        if (!empty($value)) {
+        if( !empty($value) ) {
             return [
                 'field' => 'term_id',
                 'taxonomy' => Application::TAXONOMY,
@@ -119,9 +119,9 @@ 
      * @param string $value
      * @return void|array
      */
-    protected function buildQueryEmail($value)
+    protected function buildQueryEmail( $value )
     {
-        if (!empty($value)) {
+        if( !empty($value) ) {
             return [
                 'key' => '_email',
                 'value' => $value,
@@ -133,9 +133,9 @@ 
      * @param string $value
      * @return void|array
      */
-    protected function buildQueryIpAddress($value)
+    protected function buildQueryIpAddress( $value )
     {
-        if (!empty($value)) {
+        if( !empty($value) ) {
             return [
                 'key' => '_ip_address',
                 'value' => $value,
@@ -147,10 +147,10 @@ 
      * @param string $value
      * @return void|array
      */
-    protected function buildQueryRating($value)
+    protected function buildQueryRating( $value )
     {
-        if (is_numeric($value)
-            && in_array(intval($value), range(1, glsr()->constant('MAX_RATING', Rating::class)))) {
+        if( is_numeric( $value )
+            && in_array( intval( $value ), range( 1, glsr()->constant( 'MAX_RATING', Rating::class ) ) ) ) {
             return [
                 'compare' => '>=',
                 'key' => '_rating',
@@ -163,9 +163,9 @@ 
      * @param string $value
      * @return void|array
      */
-    protected function buildQueryType($value)
+    protected function buildQueryType( $value )
     {
-        if (!in_array($value, ['', 'all'])) {
+        if( !in_array( $value, ['', 'all'] ) ) {
             return [
                 'key' => '_review_type',
                 'value' => $value,

plugin/Database/RatingManager.php

Indentation +22 added lines, -22 removed lines

@@ -8,26 +8,26 @@
 
 class RatingManager
 {
-    /**
-     * @param bool $flatten
-     * @return array
-     */
-    public function ratings(array $args = [])
-    {
-        $args = wp_parse_args($args, [
-            'max' => glsr()->constant('MAX_RATING', Rating::class),
-            'min' => glsr()->constant('MIN_RATING', Rating::class),
-        ]);
-        $ratings = [];
-        $results = glsr(Query::class)->ratings($args);
-        array_walk_recursive($results, function ($rating, $index) use (&$ratings) {
-            $ratings[$index] = $rating + intval(Arr::get($ratings, $index, 0));
-        });
-        foreach ($ratings as $index => &$rating) {
-            if (!Helper::inRange($index, $args['min'], $args['max'])) {
-                $rating = 0;
-            }
-        }
-        return $ratings;
-    }
+	/**
+	 * @param bool $flatten
+	 * @return array
+	 */
+	public function ratings(array $args = [])
+	{
+		$args = wp_parse_args($args, [
+			'max' => glsr()->constant('MAX_RATING', Rating::class),
+			'min' => glsr()->constant('MIN_RATING', Rating::class),
+		]);
+		$ratings = [];
+		$results = glsr(Query::class)->ratings($args);
+		array_walk_recursive($results, function ($rating, $index) use (&$ratings) {
+			$ratings[$index] = $rating + intval(Arr::get($ratings, $index, 0));
+		});
+		foreach ($ratings as $index => &$rating) {
+			if (!Helper::inRange($index, $args['min'], $args['max'])) {
+				$rating = 0;
+			}
+		}
+		return $ratings;
+	}
 }

Spacing +10 added lines, -10 removed lines

@@ -12,19 +12,19 @@
      * @param bool $flatten
      * @return array
      */
-    public function ratings(array $args = [])
+    public function ratings( array $args = [] )
     {
-        $args = wp_parse_args($args, [
-            'max' => glsr()->constant('MAX_RATING', Rating::class),
-            'min' => glsr()->constant('MIN_RATING', Rating::class),
-        ]);
+        $args = wp_parse_args( $args, [
+            'max' => glsr()->constant( 'MAX_RATING', Rating::class ),
+            'min' => glsr()->constant( 'MIN_RATING', Rating::class ),
+        ] );
         $ratings = [];
-        $results = glsr(Query::class)->ratings($args);
-        array_walk_recursive($results, function ($rating, $index) use (&$ratings) {
-            $ratings[$index] = $rating + intval(Arr::get($ratings, $index, 0));
+        $results = glsr( Query::class )->ratings( $args );
+        array_walk_recursive( $results, function( $rating, $index ) use (&$ratings) {
+            $ratings[$index] = $rating + intval( Arr::get( $ratings, $index, 0 ) );
         });
-        foreach ($ratings as $index => &$rating) {
-            if (!Helper::inRange($index, $args['min'], $args['max'])) {
+        foreach( $ratings as $index => &$rating ) {
+            if( !Helper::inRange( $index, $args['min'], $args['max'] ) ) {
                 $rating = 0;
             }
         }

plugin/Database/Query.php

Indentation +97 added lines, -97 removed lines

@@ -9,46 +9,46 @@ 
 
 class Query
 {
-    use QuerySql;
+	use QuerySql;
 
-    public $args;
-    public $db;
+	public $args;
+	public $db;
 
-    public function __construct()
-    {
-        global $wpdb;
-        $this->db = $wpdb;
-    }
+	public function __construct()
+	{
+		global $wpdb;
+		$this->db = $wpdb;
+	}
 
-    /**
-     * @return array
-     */
-    public function ratings(array $args)
-    {
-        $this->setArgs($args);
-        $join = implode(' ', $this->sqlClauses([], 'join'));
-        $and = implode(' ', $this->sqlClauses([], 'and'));
-        $results = $this->db->get_results("
+	/**
+	 * @return array
+	 */
+	public function ratings(array $args)
+	{
+		$this->setArgs($args);
+		$join = implode(' ', $this->sqlClauses([], 'join'));
+		$and = implode(' ', $this->sqlClauses([], 'and'));
+		$results = $this->db->get_results("
             SELECT r.rating, r.type, COUNT(r.rating) AS count
             FROM {$this->table('ratings')} AS r {$join}
             WHERE r.is_approved = 1 {$and}
             GROUP BY r.type, r.rating
         ", ARRAY_A);
-        return $this->normalizeRatings($results);
-    }
+		return $this->normalizeRatings($results);
+	}
 
-    /**
-     * @todo make sure we delete the cached review when modifying it
-     * @param int $postId
-     * @return Review
-     */
-    public function review($postId)
-    {
-        $reviewId = Helper::castToInt($postId);
-        if (($review = glsr(Cache::class)->get($reviewId, 'reviews')) instanceof Review) {
-            return $review;
-        }
-        $result = $this->db->get_row("
+	/**
+	 * @todo make sure we delete the cached review when modifying it
+	 * @param int $postId
+	 * @return Review
+	 */
+	public function review($postId)
+	{
+		$reviewId = Helper::castToInt($postId);
+		if (($review = glsr(Cache::class)->get($reviewId, 'reviews')) instanceof Review) {
+			return $review;
+		}
+		$result = $this->db->get_row("
             {$this->sqlSelect()}
             {$this->sqlFrom()}
             {$this->sqlJoin()}
@@ -56,23 +56,23 @@ 
             WHERE r.review_id = {$reviewId}
             GROUP BY r.ID
         ");
-        $review = new Review($result);
-        if (!empty($result)) {
-            glsr(Cache::class)->store($reviewId, 'reviews', $review);
-        }
-        return $review;
-    }
+		$review = new Review($result);
+		if (!empty($result)) {
+			glsr(Cache::class)->store($reviewId, 'reviews', $review);
+		}
+		return $review;
+	}
 
-    /**
-     * @return array
-     */
-    public function reviews(array $args = [], array $postIds = [])
-    {
-        $this->setArgs($args);
-        if (!empty($postIds)) {
-            $postIds = implode(',', Arr::uniqueInt($postIds));
-        } else {
-            $postIds = "SELECT ids.* FROM (
+	/**
+	 * @return array
+	 */
+	public function reviews(array $args = [], array $postIds = [])
+	{
+		$this->setArgs($args);
+		if (!empty($postIds)) {
+			$postIds = implode(',', Arr::uniqueInt($postIds));
+		} else {
+			$postIds = "SELECT ids.* FROM (
                 SELECT r.review_id
                 {$this->sqlFrom()}
                 {$this->sqlJoinClauses()}
@@ -81,8 +81,8 @@ 
                 {$this->sqlLimit()}
                 {$this->sqlOffset()}
             ) as ids";
-        }
-        $results = $this->db->get_results("
+		}
+		$results = $this->db->get_results("
             {$this->sqlSelect()}
             {$this->sqlFrom()}
             {$this->sqlJoin()}
@@ -90,65 +90,65 @@ 
             WHERE r.review_id in ({$postIds})
             GROUP BY r.ID 
         ");
-        foreach ($results as &$result) {
-            $result = new Review($result);
-            glsr(Cache::class)->store($result->ID, 'reviews', $result);
-        }
-        return $results;
-    }
+		foreach ($results as &$result) {
+			$result = new Review($result);
+			glsr(Cache::class)->store($result->ID, 'reviews', $result);
+		}
+		return $results;
+	}
 
-    /**
-     * @return int
-     */
-    public function totalReviews(array $args = [], array $reviews = [])
-    {
-        $this->setArgs($args);
-        if (empty($this->sqlLimit()) && !empty($reviews)) {
-            return count($reviews);
-        }
-        return (int) $this->db->get_var("
+	/**
+	 * @return int
+	 */
+	public function totalReviews(array $args = [], array $reviews = [])
+	{
+		$this->setArgs($args);
+		if (empty($this->sqlLimit()) && !empty($reviews)) {
+			return count($reviews);
+		}
+		return (int) $this->db->get_var("
             SELECT COUNT(*)
             {$this->sqlFrom()}
             {$this->sqlJoin()}
             {$this->sqlWhere()}
         ");
-    }
+	}
 
-    /**
-     * @param int $postId
-     * @return bool
-     */
-    public function hasRevisions($postId)
-    {
-        $revisions = (int) $this->db->get_var("
+	/**
+	 * @param int $postId
+	 * @return bool
+	 */
+	public function hasRevisions($postId)
+	{
+		$revisions = (int) $this->db->get_var("
             SELECT COUNT(*) 
             FROM {$this->db->posts}
             WHERE post_type = 'revision' AND post_parent = {$postId}
         ");
-        return $revisions > 0;
-    }
+		return $revisions > 0;
+	}
 
-    /**
-     * @return array
-     */
-    protected function normalizeRatings(array $ratings = [])
-    {
-        $normalized = [];
-        foreach ($ratings as $result) {
-            $type = $result['type'];
-            if (!array_key_exists($type, $normalized)) {
-                $normalized[$type] = glsr(Rating::class)->emptyArray();
-            }
-            $normalized[$type] = Arr::set($normalized[$type], $result['rating'], $result['count']);
-        }
-        return $normalized;
-    }
+	/**
+	 * @return array
+	 */
+	protected function normalizeRatings(array $ratings = [])
+	{
+		$normalized = [];
+		foreach ($ratings as $result) {
+			$type = $result['type'];
+			if (!array_key_exists($type, $normalized)) {
+				$normalized[$type] = glsr(Rating::class)->emptyArray();
+			}
+			$normalized[$type] = Arr::set($normalized[$type], $result['rating'], $result['count']);
+		}
+		return $normalized;
+	}
 
-    /**
-     * @return void
-     */
-    public function setArgs(array $args = [])
-    {
-        $this->args = (new NormalizeQueryArgs($args))->toArray();
-    }
+	/**
+	 * @return void
+	 */
+	public function setArgs(array $args = [])
+	{
+		$this->args = (new NormalizeQueryArgs($args))->toArray();
+	}
 }

Spacing +41 added lines, -41 removed lines

@@ -23,18 +23,18 @@ 
     /**
      * @return array
      */
-    public function ratings(array $args)
+    public function ratings( array $args )
     {
-        $this->setArgs($args);
-        $join = implode(' ', $this->sqlClauses([], 'join'));
-        $and = implode(' ', $this->sqlClauses([], 'and'));
-        $results = $this->db->get_results("
+        $this->setArgs( $args );
+        $join = implode( ' ', $this->sqlClauses( [], 'join' ) );
+        $and = implode( ' ', $this->sqlClauses( [], 'and' ) );
+        $results = $this->db->get_results( "
             SELECT r.rating, r.type, COUNT(r.rating) AS count
-            FROM {$this->table('ratings')} AS r {$join}
+            FROM {$this->table( 'ratings' )} AS r {$join}
             WHERE r.is_approved = 1 {$and}
             GROUP BY r.type, r.rating
-        ", ARRAY_A);
-        return $this->normalizeRatings($results);
+        ", ARRAY_A );
+        return $this->normalizeRatings( $results );
     }
 
     /**
@@ -42,23 +42,23 @@ 
      * @param int $postId
      * @return Review
      */
-    public function review($postId)
+    public function review( $postId )
     {
-        $reviewId = Helper::castToInt($postId);
-        if (($review = glsr(Cache::class)->get($reviewId, 'reviews')) instanceof Review) {
+        $reviewId = Helper::castToInt( $postId );
+        if( ($review = glsr( Cache::class )->get( $reviewId, 'reviews' )) instanceof Review ) {
             return $review;
         }
-        $result = $this->db->get_row("
+        $result = $this->db->get_row( "
             {$this->sqlSelect()}
             {$this->sqlFrom()}
             {$this->sqlJoin()}
             {$this->sqlJoinPivots()}
             WHERE r.review_id = {$reviewId}
             GROUP BY r.ID
-        ");
-        $review = new Review($result);
-        if (!empty($result)) {
-            glsr(Cache::class)->store($reviewId, 'reviews', $review);
+        " );
+        $review = new Review( $result );
+        if( !empty($result) ) {
+            glsr( Cache::class )->store( $reviewId, 'reviews', $review );
         }
         return $review;
     }
@@ -66,11 +66,11 @@ 
     /**
      * @return array
      */
-    public function reviews(array $args = [], array $postIds = [])
+    public function reviews( array $args = [], array $postIds = [] )
     {
-        $this->setArgs($args);
-        if (!empty($postIds)) {
-            $postIds = implode(',', Arr::uniqueInt($postIds));
+        $this->setArgs( $args );
+        if( !empty($postIds) ) {
+            $postIds = implode( ',', Arr::uniqueInt( $postIds ) );
         } else {
             $postIds = "SELECT ids.* FROM (
                 SELECT r.review_id
@@ -82,17 +82,17 @@ 
                 {$this->sqlOffset()}
             ) as ids";
         }
-        $results = $this->db->get_results("
+        $results = $this->db->get_results( "
             {$this->sqlSelect()}
             {$this->sqlFrom()}
             {$this->sqlJoin()}
             {$this->sqlJoinPivots()}
             WHERE r.review_id in ({$postIds})
             GROUP BY r.ID 
-        ");
-        foreach ($results as &$result) {
-            $result = new Review($result);
-            glsr(Cache::class)->store($result->ID, 'reviews', $result);
+        " );
+        foreach( $results as &$result ) {
+            $result = new Review( $result );
+            glsr( Cache::class )->store( $result->ID, 'reviews', $result );
         }
         return $results;
     }
@@ -100,46 +100,46 @@ 
     /**
      * @return int
      */
-    public function totalReviews(array $args = [], array $reviews = [])
+    public function totalReviews( array $args = [], array $reviews = [] )
     {
-        $this->setArgs($args);
-        if (empty($this->sqlLimit()) && !empty($reviews)) {
-            return count($reviews);
+        $this->setArgs( $args );
+        if( empty($this->sqlLimit()) && !empty($reviews) ) {
+            return count( $reviews );
         }
-        return (int) $this->db->get_var("
+        return (int)$this->db->get_var( "
             SELECT COUNT(*)
             {$this->sqlFrom()}
             {$this->sqlJoin()}
             {$this->sqlWhere()}
-        ");
+        " );
     }
 
     /**
      * @param int $postId
      * @return bool
      */
-    public function hasRevisions($postId)
+    public function hasRevisions( $postId )
     {
-        $revisions = (int) $this->db->get_var("
+        $revisions = (int)$this->db->get_var( "
             SELECT COUNT(*) 
             FROM {$this->db->posts}
             WHERE post_type = 'revision' AND post_parent = {$postId}
-        ");
+        " );
         return $revisions > 0;
     }
 
     /**
      * @return array
      */
-    protected function normalizeRatings(array $ratings = [])
+    protected function normalizeRatings( array $ratings = [] )
     {
         $normalized = [];
-        foreach ($ratings as $result) {
+        foreach( $ratings as $result ) {
             $type = $result['type'];
-            if (!array_key_exists($type, $normalized)) {
-                $normalized[$type] = glsr(Rating::class)->emptyArray();
+            if( !array_key_exists( $type, $normalized ) ) {
+                $normalized[$type] = glsr( Rating::class )->emptyArray();
             }
-            $normalized[$type] = Arr::set($normalized[$type], $result['rating'], $result['count']);
+            $normalized[$type] = Arr::set( $normalized[$type], $result['rating'], $result['count'] );
         }
         return $normalized;
     }
@@ -147,8 +147,8 @@ 
     /**
      * @return void
      */
-    public function setArgs(array $args = [])
+    public function setArgs( array $args = [] )
     {
-        $this->args = (new NormalizeQueryArgs($args))->toArray();
+        $this->args = (new NormalizeQueryArgs( $args ))->toArray();
     }
 }

Braces +2 added lines, -1 removed lines

@@ -71,7 +71,8 @@
         $this->setArgs($args);
         if (!empty($postIds)) {
             $postIds = implode(',', Arr::uniqueInt($postIds));
-        } else {
+        }
+        else {
             $postIds = "SELECT ids.* FROM (
                 SELECT r.review_id
                 {$this->sqlFrom()}