Elgg / Elgg

engine/classes/Elgg/Views/TableColumn/ViewColumn.php

Indentation +51 added lines, -51 removed lines

@@ -8,55 +8,55 @@
  */
 class ViewColumn implements TableColumn {
 
-	/**
-	 * @var string
-	 */
-	private $heading;
-
-	/**
-	 * @var string
-	 */
-	private $view;
-
-	/**
-	 * @var array
-	 */
-	private $vars;
-
-	/**
-	 * Constructor
-	 *
-	 * @param string $view    The view to render the value
-	 * @param string $heading Heading
-	 * @param array  $vars    Vars to merge into the view vars
-	 */
-	public function __construct($view, $heading = null, $vars = []) {
-		$this->view = $view;
-		$this->vars = $vars;
-
-		if (!is_string($heading)) {
-			$heading = elgg_echo("ViewColumn:view:$view");
-		}
-		$this->heading = $heading;
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function renderHeading() {
-		return $this->heading;
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function renderCell($item, $type, $item_vars) {
-		$vars = array_merge($this->vars, [
-			'item' => $item,
-			'item_vars' => $item_vars,
-			'type' => $type,
-		]);
-
-		return elgg_view($this->view, $vars);
-	}
+    /**
+     * @var string
+     */
+    private $heading;
+
+    /**
+     * @var string
+     */
+    private $view;
+
+    /**
+     * @var array
+     */
+    private $vars;
+
+    /**
+     * Constructor
+     *
+     * @param string $view    The view to render the value
+     * @param string $heading Heading
+     * @param array  $vars    Vars to merge into the view vars
+     */
+    public function __construct($view, $heading = null, $vars = []) {
+        $this->view = $view;
+        $this->vars = $vars;
+
+        if (!is_string($heading)) {
+            $heading = elgg_echo("ViewColumn:view:$view");
+        }
+        $this->heading = $heading;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function renderHeading() {
+        return $this->heading;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function renderCell($item, $type, $item_vars) {
+        $vars = array_merge($this->vars, [
+            'item' => $item,
+            'item_vars' => $item_vars,
+            'type' => $type,
+        ]);
+
+        return elgg_view($this->view, $vars);
+    }
 }

engine/classes/ElggBatch.php

Indentation +417 added lines, -417 removed lines

@@ -72,422 +72,422 @@
  */
 class ElggBatch implements BatchResult {
 
-	/**
-	 * The objects to iterate over.
-	 *
-	 * @var array
-	 */
-	private $results = array();
-
-	/**
-	 * The function used to get results.
-	 *
-	 * @var callable
-	 */
-	private $getter = null;
-
-	/**
-	 * The given $options to alter and pass to the getter.
-	 *
-	 * @var array
-	 */
-	private $options = array();
-
-	/**
-	 * The number of results to grab at a time.
-	 *
-	 * @var int
-	 */
-	private $chunkSize = 25;
-
-	/**
-	 * A callback function to pass results through.
-	 *
-	 * @var callable
-	 */
-	private $callback = null;
-
-	/**
-	 * Start after this many results.
-	 *
-	 * @var int
-	 */
-	private $offset = 0;
-
-	/**
-	 * Stop after this many results.
-	 *
-	 * @var int
-	 */
-	private $limit = 0;
-
-	/**
-	 * Number of processed results.
-	 *
-	 * @var int
-	 */
-	private $retrievedResults = 0;
-
-	/**
-	 * The index of the current result within the current chunk
-	 *
-	 * @var int
-	 */
-	private $resultIndex = 0;
-
-	/**
-	 * The index of the current chunk
-	 *
-	 * @var int
-	 */
-	private $chunkIndex = 0;
-
-	/**
-	 * The number of results iterated through
-	 *
-	 * @var int
-	 */
-	private $processedResults = 0;
-
-	/**
-	 * Is the getter a valid callback
-	 *
-	 * @var bool
-	 */
-	private $validGetter = null;
-
-	/**
-	 * The result of running all entities through the callback function.
-	 *
-	 * @var mixed
-	 */
-	public $callbackResult = null;
-
-	/**
-	 * If false, offset will not be incremented. This is used for callbacks/loops that delete.
-	 *
-	 * @var bool
-	 */
-	private $incrementOffset = true;
-
-	/**
-	 * Entities that could not be instantiated during a fetch
-	 *
-	 * @var \stdClass[]
-	 */
-	private $incompleteEntities = array();
-
-	/**
-	 * Total number of incomplete entities fetched
-	 *
-	 * @var int
-	 */
-	private $totalIncompletes = 0;
-
-	/**
-	 * Batches operations on any elgg_get_*() or compatible function that supports
-	 * an options array.
-	 *
-	 * Instead of returning all objects in memory, it goes through $chunk_size
-	 * objects, then requests more from the server.  This avoids OOM errors.
-	 *
-	 * @param string $getter     The function used to get objects.  Usually
-	 *                           an elgg_get_*() function, but can be any valid PHP callback.
-	 * @param array  $options    The options array to pass to the getter function. If limit is
-	 *                           not set, 10 is used as the default. In most cases that is not
-	 *                           what you want.
-	 * @param mixed  $callback   An optional callback function that all results will be passed
-	 *                           to upon load.  The callback needs to accept $result, $getter,
-	 *                           $options.
-	 * @param int    $chunk_size The number of entities to pull in before requesting more.
-	 *                           You have to balance this between running out of memory in PHP
-	 *                           and hitting the db server too often.
-	 * @param bool   $inc_offset Increment the offset on each fetch. This must be false for
-	 *                           callbacks that delete rows. You can set this after the
-	 *                           object is created with {@link \ElggBatch::setIncrementOffset()}.
-	 */
-	public function __construct($getter, $options, $callback = null, $chunk_size = 25,
-			$inc_offset = true) {
+    /**
+     * The objects to iterate over.
+     *
+     * @var array
+     */
+    private $results = array();
+
+    /**
+     * The function used to get results.
+     *
+     * @var callable
+     */
+    private $getter = null;
+
+    /**
+     * The given $options to alter and pass to the getter.
+     *
+     * @var array
+     */
+    private $options = array();
+
+    /**
+     * The number of results to grab at a time.
+     *
+     * @var int
+     */
+    private $chunkSize = 25;
+
+    /**
+     * A callback function to pass results through.
+     *
+     * @var callable
+     */
+    private $callback = null;
+
+    /**
+     * Start after this many results.
+     *
+     * @var int
+     */
+    private $offset = 0;
+
+    /**
+     * Stop after this many results.
+     *
+     * @var int
+     */
+    private $limit = 0;
+
+    /**
+     * Number of processed results.
+     *
+     * @var int
+     */
+    private $retrievedResults = 0;
+
+    /**
+     * The index of the current result within the current chunk
+     *
+     * @var int
+     */
+    private $resultIndex = 0;
+
+    /**
+     * The index of the current chunk
+     *
+     * @var int
+     */
+    private $chunkIndex = 0;
+
+    /**
+     * The number of results iterated through
+     *
+     * @var int
+     */
+    private $processedResults = 0;
+
+    /**
+     * Is the getter a valid callback
+     *
+     * @var bool
+     */
+    private $validGetter = null;
+
+    /**
+     * The result of running all entities through the callback function.
+     *
+     * @var mixed
+     */
+    public $callbackResult = null;
+
+    /**
+     * If false, offset will not be incremented. This is used for callbacks/loops that delete.
+     *
+     * @var bool
+     */
+    private $incrementOffset = true;
+
+    /**
+     * Entities that could not be instantiated during a fetch
+     *
+     * @var \stdClass[]
+     */
+    private $incompleteEntities = array();
+
+    /**
+     * Total number of incomplete entities fetched
+     *
+     * @var int
+     */
+    private $totalIncompletes = 0;
+
+    /**
+     * Batches operations on any elgg_get_*() or compatible function that supports
+     * an options array.
+     *
+     * Instead of returning all objects in memory, it goes through $chunk_size
+     * objects, then requests more from the server.  This avoids OOM errors.
+     *
+     * @param string $getter     The function used to get objects.  Usually
+     *                           an elgg_get_*() function, but can be any valid PHP callback.
+     * @param array  $options    The options array to pass to the getter function. If limit is
+     *                           not set, 10 is used as the default. In most cases that is not
+     *                           what you want.
+     * @param mixed  $callback   An optional callback function that all results will be passed
+     *                           to upon load.  The callback needs to accept $result, $getter,
+     *                           $options.
+     * @param int    $chunk_size The number of entities to pull in before requesting more.
+     *                           You have to balance this between running out of memory in PHP
+     *                           and hitting the db server too often.
+     * @param bool   $inc_offset Increment the offset on each fetch. This must be false for
+     *                           callbacks that delete rows. You can set this after the
+     *                           object is created with {@link \ElggBatch::setIncrementOffset()}.
+     */
+    public function __construct($getter, $options, $callback = null, $chunk_size = 25,
+            $inc_offset = true) {
 		
-		$this->getter = $getter;
-		$this->options = $options;
-		$this->callback = $callback;
-		$this->chunkSize = $chunk_size;
-		$this->setIncrementOffset($inc_offset);
-
-		if ($this->chunkSize <= 0) {
-			$this->chunkSize = 25;
-		}
-
-		// store these so we can compare later
-		$this->offset = elgg_extract('offset', $options, 0);
-		$this->limit = elgg_extract('limit', $options, elgg_get_config('default_limit'));
-
-		// if passed a callback, create a new \ElggBatch with the same options
-		// and pass each to the callback.
-		if ($callback && is_callable($callback)) {
-			$batch = new \ElggBatch($getter, $options, null, $chunk_size, $inc_offset);
-
-			$all_results = null;
-
-			foreach ($batch as $result) {
-				$result = call_user_func($callback, $result, $getter, $options);
-
-				if (!isset($all_results)) {
-					if ($result === true || $result === false || $result === null) {
-						$all_results = $result;
-					} else {
-						$all_results = array();
-					}
-				}
-
-				if (($result === true || $result === false || $result === null) && !is_array($all_results)) {
-					$all_results = $result && $all_results;
-				} else {
-					$all_results[] = $result;
-				}
-			}
-
-			$this->callbackResult = $all_results;
-		}
-	}
-
-	/**
-	 * Tell the process that an entity was incomplete during a fetch
-	 *
-	 * @param \stdClass $row
-	 *
-	 * @access private
-	 */
-	public function reportIncompleteEntity(\stdClass $row) {
-		$this->incompleteEntities[] = $row;
-	}
-
-	/**
-	 * Fetches the next chunk of results
-	 *
-	 * @return bool
-	 */
-	private function getNextResultsChunk() {
-
-		// always reset results.
-		$this->results = array();
-
-		if (!isset($this->validGetter)) {
-			$this->validGetter = is_callable($this->getter);
-		}
-
-		if (!$this->validGetter) {
-			return false;
-		}
-
-		$limit = $this->chunkSize;
-
-		// if someone passed limit = 0 they want everything.
-		if ($this->limit != 0) {
-			if ($this->retrievedResults >= $this->limit) {
-				return false;
-			}
-
-			// if original limit < chunk size, set limit to original limit
-			// else if the number of results we'll fetch if greater than the original limit
-			if ($this->limit < $this->chunkSize) {
-				$limit = $this->limit;
-			} elseif ($this->retrievedResults + $this->chunkSize > $this->limit) {
-				// set the limit to the number of results remaining in the original limit
-				$limit = $this->limit - $this->retrievedResults;
-			}
-		}
-
-		if ($this->incrementOffset) {
-			$offset = $this->offset + $this->retrievedResults;
-		} else {
-			$offset = $this->offset + $this->totalIncompletes;
-		}
-
-		$current_options = array(
-			'limit' => $limit,
-			'offset' => $offset,
-			'__ElggBatch' => $this,
-		);
-
-		$options = array_merge($this->options, $current_options);
-
-		$this->incompleteEntities = array();
-		$this->results = call_user_func($this->getter, $options);
-
-		// batch result sets tend to be large; we don't want to cache these.
-		_elgg_services()->db->disableQueryCache();
-
-		$num_results = count($this->results);
-		$num_incomplete = count($this->incompleteEntities);
-
-		$this->totalIncompletes += $num_incomplete;
-
-		if ($this->incompleteEntities) {
-			// pad the front of the results with nulls representing the incompletes
-			array_splice($this->results, 0, 0, array_pad(array(), $num_incomplete, null));
-			// ...and skip past them
-			reset($this->results);
-			for ($i = 0; $i < $num_incomplete; $i++) {
-				next($this->results);
-			}
-		}
-
-		if ($this->results) {
-			$this->chunkIndex++;
-
-			// let the system know we've jumped past the nulls
-			$this->resultIndex = $num_incomplete;
-
-			$this->retrievedResults += ($num_results + $num_incomplete);
-			if ($num_results == 0) {
-				// This fetch was *all* incompletes! We need to fetch until we can either
-				// offer at least one row to iterate over, or give up.
-				return $this->getNextResultsChunk();
-			}
-			_elgg_services()->db->enableQueryCache();
-			return true;
-		} else {
-			_elgg_services()->db->enableQueryCache();
-			return false;
-		}
-	}
-
-	/**
-	 * Increment the offset from the original options array? Setting to
-	 * false is required for callbacks that delete rows.
-	 *
-	 * @param bool $increment Set to false when deleting data
-	 * @return void
-	 */
-	public function setIncrementOffset($increment = true) {
-		$this->incrementOffset = (bool) $increment;
-	}
-
-	/**
-	 * Implements Iterator
-	 */
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function rewind() {
-		$this->resultIndex = 0;
-		$this->retrievedResults = 0;
-		$this->processedResults = 0;
-
-		// only grab results if we haven't yet or we're crossing chunks
-		if ($this->chunkIndex == 0 || $this->limit > $this->chunkSize) {
-			$this->chunkIndex = 0;
-			$this->getNextResultsChunk();
-		}
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function current() {
-		return current($this->results);
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function key() {
-		return $this->processedResults;
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function next() {
-		// if we'll be at the end.
-		if (($this->processedResults + 1) >= $this->limit && $this->limit > 0) {
-			$this->results = array();
-			return false;
-		}
-
-		// if we'll need new results.
-		if (($this->resultIndex + 1) >= $this->chunkSize) {
-			if (!$this->getNextResultsChunk()) {
-				$this->results = array();
-				return false;
-			}
-
-			$result = current($this->results);
-		} else {
-			// the function above resets the indexes, so only inc if not
-			// getting new set
-			$this->resultIndex++;
-			$result = next($this->results);
-		}
-
-		$this->processedResults++;
-		return $result;
-	}
-
-	/**
-	 * {@inheritdoc}
-	 */
-	public function valid() {
-		if (!is_array($this->results)) {
-			return false;
-		}
-		$key = key($this->results);
-		return ($key !== null && $key !== false);
-	}
-
-	/**
-	 * Count the total results available at this moment.
-	 *
-	 * As this performs a separate query, the count returned may not match the number of results you can
-	 * fetch via iteration on a very active DB.
-	 *
-	 * @see Countable::count()
-	 * @return int
-	 */
-	public function count() {
-		if (!is_callable($this->getter)) {
-			$inspector = new \Elgg\Debug\Inspector();
-			throw new RuntimeException("Getter is not callable: " . $inspector->describeCallable($this->getter));
-		}
-
-		$options = array_merge($this->options, ['count' => true]);
-
-		return call_user_func($this->getter, $options);
-	}
-
-	/**
-	 * Read a property
-	 *
-	 * @param string $name
-	 * @return mixed
-	 * @access private
-	 */
-	public function __get($name) {
-		if ($name === 'options') {
-			elgg_deprecated_notice("The ElggBatch 'options' property is private and should not be used", "2.3");
-			return $this->options;
-		}
-
-		_elgg_services()->logger->warn("Read of non-existent property '$name'");
-		return null;
-	}
-
-	/**
-	 * Write a property
-	 *
-	 * @param string $name
-	 * @param mixed  $value
-	 * @return void
-	 * @access private
-	 */
-	public function __set($name, $value) {
-		if ($name === 'options') {
-			elgg_deprecated_notice("The ElggBatch 'options' property is private and should not be used", "2.3");
-		}
-
-		$this->{$name} = $value;
-	}
+        $this->getter = $getter;
+        $this->options = $options;
+        $this->callback = $callback;
+        $this->chunkSize = $chunk_size;
+        $this->setIncrementOffset($inc_offset);
+
+        if ($this->chunkSize <= 0) {
+            $this->chunkSize = 25;
+        }
+
+        // store these so we can compare later
+        $this->offset = elgg_extract('offset', $options, 0);
+        $this->limit = elgg_extract('limit', $options, elgg_get_config('default_limit'));
+
+        // if passed a callback, create a new \ElggBatch with the same options
+        // and pass each to the callback.
+        if ($callback && is_callable($callback)) {
+            $batch = new \ElggBatch($getter, $options, null, $chunk_size, $inc_offset);
+
+            $all_results = null;
+
+            foreach ($batch as $result) {
+                $result = call_user_func($callback, $result, $getter, $options);
+
+                if (!isset($all_results)) {
+                    if ($result === true || $result === false || $result === null) {
+                        $all_results = $result;
+                    } else {
+                        $all_results = array();
+                    }
+                }
+
+                if (($result === true || $result === false || $result === null) && !is_array($all_results)) {
+                    $all_results = $result && $all_results;
+                } else {
+                    $all_results[] = $result;
+                }
+            }
+
+            $this->callbackResult = $all_results;
+        }
+    }
+
+    /**
+     * Tell the process that an entity was incomplete during a fetch
+     *
+     * @param \stdClass $row
+     *
+     * @access private
+     */
+    public function reportIncompleteEntity(\stdClass $row) {
+        $this->incompleteEntities[] = $row;
+    }
+
+    /**
+     * Fetches the next chunk of results
+     *
+     * @return bool
+     */
+    private function getNextResultsChunk() {
+
+        // always reset results.
+        $this->results = array();
+
+        if (!isset($this->validGetter)) {
+            $this->validGetter = is_callable($this->getter);
+        }
+
+        if (!$this->validGetter) {
+            return false;
+        }
+
+        $limit = $this->chunkSize;
+
+        // if someone passed limit = 0 they want everything.
+        if ($this->limit != 0) {
+            if ($this->retrievedResults >= $this->limit) {
+                return false;
+            }
+
+            // if original limit < chunk size, set limit to original limit
+            // else if the number of results we'll fetch if greater than the original limit
+            if ($this->limit < $this->chunkSize) {
+                $limit = $this->limit;
+            } elseif ($this->retrievedResults + $this->chunkSize > $this->limit) {
+                // set the limit to the number of results remaining in the original limit
+                $limit = $this->limit - $this->retrievedResults;
+            }
+        }
+
+        if ($this->incrementOffset) {
+            $offset = $this->offset + $this->retrievedResults;
+        } else {
+            $offset = $this->offset + $this->totalIncompletes;
+        }
+
+        $current_options = array(
+            'limit' => $limit,
+            'offset' => $offset,
+            '__ElggBatch' => $this,
+        );
+
+        $options = array_merge($this->options, $current_options);
+
+        $this->incompleteEntities = array();
+        $this->results = call_user_func($this->getter, $options);
+
+        // batch result sets tend to be large; we don't want to cache these.
+        _elgg_services()->db->disableQueryCache();
+
+        $num_results = count($this->results);
+        $num_incomplete = count($this->incompleteEntities);
+
+        $this->totalIncompletes += $num_incomplete;
+
+        if ($this->incompleteEntities) {
+            // pad the front of the results with nulls representing the incompletes
+            array_splice($this->results, 0, 0, array_pad(array(), $num_incomplete, null));
+            // ...and skip past them
+            reset($this->results);
+            for ($i = 0; $i < $num_incomplete; $i++) {
+                next($this->results);
+            }
+        }
+
+        if ($this->results) {
+            $this->chunkIndex++;
+
+            // let the system know we've jumped past the nulls
+            $this->resultIndex = $num_incomplete;
+
+            $this->retrievedResults += ($num_results + $num_incomplete);
+            if ($num_results == 0) {
+                // This fetch was *all* incompletes! We need to fetch until we can either
+                // offer at least one row to iterate over, or give up.
+                return $this->getNextResultsChunk();
+            }
+            _elgg_services()->db->enableQueryCache();
+            return true;
+        } else {
+            _elgg_services()->db->enableQueryCache();
+            return false;
+        }
+    }
+
+    /**
+     * Increment the offset from the original options array? Setting to
+     * false is required for callbacks that delete rows.
+     *
+     * @param bool $increment Set to false when deleting data
+     * @return void
+     */
+    public function setIncrementOffset($increment = true) {
+        $this->incrementOffset = (bool) $increment;
+    }
+
+    /**
+     * Implements Iterator
+     */
+
+    /**
+     * {@inheritdoc}
+     */
+    public function rewind() {
+        $this->resultIndex = 0;
+        $this->retrievedResults = 0;
+        $this->processedResults = 0;
+
+        // only grab results if we haven't yet or we're crossing chunks
+        if ($this->chunkIndex == 0 || $this->limit > $this->chunkSize) {
+            $this->chunkIndex = 0;
+            $this->getNextResultsChunk();
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function current() {
+        return current($this->results);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function key() {
+        return $this->processedResults;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function next() {
+        // if we'll be at the end.
+        if (($this->processedResults + 1) >= $this->limit && $this->limit > 0) {
+            $this->results = array();
+            return false;
+        }
+
+        // if we'll need new results.
+        if (($this->resultIndex + 1) >= $this->chunkSize) {
+            if (!$this->getNextResultsChunk()) {
+                $this->results = array();
+                return false;
+            }
+
+            $result = current($this->results);
+        } else {
+            // the function above resets the indexes, so only inc if not
+            // getting new set
+            $this->resultIndex++;
+            $result = next($this->results);
+        }
+
+        $this->processedResults++;
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function valid() {
+        if (!is_array($this->results)) {
+            return false;
+        }
+        $key = key($this->results);
+        return ($key !== null && $key !== false);
+    }
+
+    /**
+     * Count the total results available at this moment.
+     *
+     * As this performs a separate query, the count returned may not match the number of results you can
+     * fetch via iteration on a very active DB.
+     *
+     * @see Countable::count()
+     * @return int
+     */
+    public function count() {
+        if (!is_callable($this->getter)) {
+            $inspector = new \Elgg\Debug\Inspector();
+            throw new RuntimeException("Getter is not callable: " . $inspector->describeCallable($this->getter));
+        }
+
+        $options = array_merge($this->options, ['count' => true]);
+
+        return call_user_func($this->getter, $options);
+    }
+
+    /**
+     * Read a property
+     *
+     * @param string $name
+     * @return mixed
+     * @access private
+     */
+    public function __get($name) {
+        if ($name === 'options') {
+            elgg_deprecated_notice("The ElggBatch 'options' property is private and should not be used", "2.3");
+            return $this->options;
+        }
+
+        _elgg_services()->logger->warn("Read of non-existent property '$name'");
+        return null;
+    }
+
+    /**
+     * Write a property
+     *
+     * @param string $name
+     * @param mixed  $value
+     * @return void
+     * @access private
+     */
+    public function __set($name, $value) {
+        if ($name === 'options') {
+            elgg_deprecated_notice("The ElggBatch 'options' property is private and should not be used", "2.3");
+        }
+
+        $this->{$name} = $value;
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -450,7 +450,7 @@
 	public function count() {
 		if (!is_callable($this->getter)) {
 			$inspector = new \Elgg\Debug\Inspector();
-			throw new RuntimeException("Getter is not callable: " . $inspector->describeCallable($this->getter));
+			throw new RuntimeException("Getter is not callable: ".$inspector->describeCallable($this->getter));
 		}
 
 		$options = array_merge($this->options, ['count' => true]);