Merge branch '0.9.x' into refactor-api

* 0.9.x:
  make lib/schema.php phpcs-clean

1 files changed, 272 insertions, 37 deletions

diff --git a/lib/schema.php b/lib/schema.php
index 8c8f5e9ff..1e0c1f3e9 100644
--- a/lib/schema.php
+++ b/lib/schema.php
@@ -50,15 +50,29 @@ class Schema
     static $_single = null;
     protected $conn = null;
 
+    /**
+     * Constructor. Only run once for singleton object.
+     */
+
     protected function __construct()
     {
         // XXX: there should be an easier way to do this.
         $user = new User();
+
         $this->conn = $user->getDatabaseConnection();
+
         $user->free();
+
         unset($user);
     }
 
+    /**
+     * Main public entry point. Use this to get
+     * the singleton object.
+     *
+     * @return Schema the (single) Schema object
+     */
+
     static function get()
     {
         if (empty(self::$_single)) {
@@ -67,6 +81,17 @@ class Schema
         return self::$_single;
     }
 
+    /**
+     * Returns a TableDef object for the table
+     * in the schema with the given name.
+     *
+     * Throws an exception if the table is not found.
+     *
+     * @param string $name Name of the table to get
+     *
+     * @return TableDef tabledef for that table.
+     */
+
     public function getTableDef($name)
     {
         $res =& $this->conn->query('DESCRIBE ' . $name);
@@ -108,6 +133,18 @@ class Schema
         return $td;
     }
 
+    /**
+     * Gets a ColumnDef object for a single column.
+     *
+     * Throws an exception if the table is not found.
+     *
+     * @param string $table  name of the table
+     * @param string $column name of the column
+     *
+     * @return ColumnDef definition of the column or null
+     *                   if not found.
+     */
+
     public function getColumnDef($table, $column)
     {
         $td = $this->getTableDef($table);
@@ -121,12 +158,17 @@ class Schema
         return null;
     }
 
-    public function getIndexDef($table, $index)
-    {
-        return null;
-    }
-
-    public function createTable($name, $columns, $indices=null)
+    /**
+     * Creates a table with the given names and columns.
+     *
+     * @param string $name    Name of the table
+     * @param array  $columns Array of ColumnDef objects
+     *                        for new table.
+     *
+     * @return boolean success flag
+     */
+
+    public function createTable($name, $columns)
     {
         $uniques = array();
         $primary = array();
@@ -145,13 +187,13 @@ class Schema
             $sql .= $this->_columnSql($cd);
 
             switch ($cd->key) {
-             case 'UNI':
+            case 'UNI':
                 $uniques[] = $cd->name;
                 break;
-             case 'PRI':
+            case 'PRI':
                 $primary[] = $cd->name;
                 break;
-             case 'MUL':
+            case 'MUL':
                 $indices[] = $cd->name;
                 break;
             }
@@ -171,8 +213,6 @@ class Schema
 
         $sql .= "); ";
 
-        common_debug($sql);
-
         $res =& $this->conn->query($sql);
 
         if (PEAR::isError($res)) {
@@ -182,6 +222,16 @@ class Schema
         return true;
     }
 
+    /**
+     * Drops a table from the schema
+     *
+     * Throws an exception if the table is not found.
+     *
+     * @param string $name Name of the table to drop
+     *
+     * @return boolean success flag
+     */
+
     public function dropTable($name)
     {
         $res =& $this->conn->query("DROP TABLE $name");
@@ -193,7 +243,23 @@ class Schema
         return true;
     }
 
-    public function createIndex($table, $columnNames, $name = null)
+    /**
+     * Adds an index to a table.
+     *
+     * If no name is provided, a name will be made up based
+     * on the table name and column names.
+     *
+     * Throws an exception on database error, esp. if the table
+     * does not exist.
+     *
+     * @param string $table       Name of the table
+     * @param array  $columnNames Name of columns to index
+     * @param string $name        (Optional) name of the index
+     *
+     * @return boolean success flag
+     */
+
+    public function createIndex($table, $columnNames, $name=null)
     {
         if (!is_array($columnNames)) {
             $columnNames = array($columnNames);
@@ -203,7 +269,9 @@ class Schema
             $name = "$table_".implode("_", $columnNames)."_idx";
         }
 
-        $res =& $this->conn->query("ALTER TABLE $table ADD INDEX $name (".implode(",", $columnNames).")");
+        $res =& $this->conn->query("ALTER TABLE $table ".
+                                   "ADD INDEX $name (".
+                                   implode(",", $columnNames).")");
 
         if (PEAR::isError($res)) {
             throw new Exception($res->getMessage());
@@ -212,6 +280,15 @@ class Schema
         return true;
     }
 
+    /**
+     * Drops a named index from a table.
+     *
+     * @param string $table name of the table the index is on.
+     * @param string $name  name of the index
+     *
+     * @return boolean success flag
+     */
+
     public function dropIndex($table, $name)
     {
         $res =& $this->conn->query("ALTER TABLE $table DROP INDEX $name");
@@ -223,6 +300,16 @@ class Schema
         return true;
     }
 
+    /**
+     * Adds a column to a table
+     *
+     * @param string    $table     name of the table
+     * @param ColumnDef $columndef Definition of the new
+     *                             column.
+     *
+     * @return boolean success flag
+     */
+
     public function addColumn($table, $columndef)
     {
         $sql = "ALTER TABLE $table ADD COLUMN " . $this->_columnSql($columndef);
@@ -236,9 +323,21 @@ class Schema
         return true;
     }
 
+    /**
+     * Modifies a column in the schema.
+     *
+     * The name must match an existing column and table.
+     *
+     * @param string    $table     name of the table
+     * @param ColumnDef $columndef new definition of the column.
+     *
+     * @return boolean success flag
+     */
+
     public function modifyColumn($table, $columndef)
     {
-        $sql = "ALTER TABLE $table MODIFY COLUMN " . $this->_columnSql($columndef);
+        $sql = "ALTER TABLE $table MODIFY COLUMN " .
+          $this->_columnSql($columndef);
 
         $res =& $this->conn->query($sql);
 
@@ -249,6 +348,17 @@ class Schema
         return true;
     }
 
+    /**
+     * Drops a column from a table
+     *
+     * The name must match an existing column.
+     *
+     * @param string $table      name of the table
+     * @param string $columnName name of the column to drop
+     *
+     * @return boolean success flag
+     */
+
     public function dropColumn($table, $columnName)
     {
         $sql = "ALTER TABLE $table DROP COLUMN $columnName";
@@ -262,7 +372,22 @@ class Schema
         return true;
     }
 
-    public function ensureTable($tableName, $columns, $indices=null)
+    /**
+     * Ensures that a table exists with the given
+     * name and the given column definitions.
+     *
+     * If the table does not yet exist, it will
+     * create the table. If it does exist, it will
+     * alter the table to match the column definitions.
+     *
+     * @param string $tableName name of the table
+     * @param array  $columns   array of ColumnDef
+     *                          objects for the table
+     *
+     * @return boolean success flag
+     */
+
+    public function ensureTable($tableName, $columns)
     {
         // XXX: DB engine portability -> toilet
 
@@ -270,7 +395,7 @@ class Schema
             $td = $this->getTableDef($tableName);
         } catch (Exception $e) {
             if (preg_match('/no such table/', $e->getMessage())) {
-                return $this->createTable($tableName, $columns, $indices);
+                return $this->createTable($tableName, $columns);
             } else {
                 throw $e;
             }
@@ -281,10 +406,8 @@ class Schema
 
         $toadd  = array_diff($new, $cur);
         $todrop = array_diff($cur, $new);
-
-        $same  = array_intersect($new, $cur);
-
-        $tomod = array();
+        $same   = array_intersect($new, $cur);
+        $tomod  = array();
 
         foreach ($same as $m) {
             $curCol = $this->_byName($td->columns, $m);
@@ -307,6 +430,7 @@ class Schema
 
         foreach ($toadd as $columnName) {
             $cd = $this->_byName($columns, $columnName);
+
             $phrase[] = 'ADD COLUMN ' . $this->_columnSql($cd);
         }
 
@@ -316,6 +440,7 @@ class Schema
 
         foreach ($tomod as $columnName) {
             $cd = $this->_byName($columns, $columnName);
+
             $phrase[] = 'MODIFY COLUMN ' . $this->_columnSql($cd);
         }
 
@@ -330,7 +455,16 @@ class Schema
         return true;
     }
 
-    function _names($cds)
+    /**
+     * Returns the array of names from an array of
+     * ColumnDef objects.
+     *
+     * @param array $cds array of ColumnDef objects
+     *
+     * @return array strings for name values
+     */
+
+    private function _names($cds)
     {
         $names = array();
 
@@ -341,7 +475,17 @@ class Schema
         return $names;
     }
 
-    function _byName($cds, $name)
+    /**
+     * Get a ColumnDef from an array matching
+     * name.
+     *
+     * @param array  $cds  Array of ColumnDef objects
+     * @param string $name Name of the column
+     *
+     * @return ColumnDef matching item or null if no match.
+     */
+
+    private function _byName($cds, $name)
     {
         foreach ($cds as $cd) {
             if ($cd->name == $name) {
@@ -352,7 +496,19 @@ class Schema
         return null;
     }
 
-    function _columnSql($cd)
+    /**
+     * Return the proper SQL for creating or
+     * altering a column.
+     *
+     * Appropriate for use in CREATE TABLE or
+     * ALTER TABLE statements.
+     *
+     * @param ColumnDef $cd column to create
+     *
+     * @return string correct SQL for that column
+     */
+
+    private function _columnSql($cd)
     {
         $sql = "{$cd->name} ";
 
@@ -372,25 +528,71 @@ class Schema
     }
 }
 
+/**
+ * A class encapsulating the structure of a table.
+ *
+ * @category Database
+ * @package  StatusNet
+ * @author   Evan Prodromou <evan@status.net>
+ * @license  http://www.fsf.org/licensing/licenses/agpl-3.0.html GNU Affero General Public License version 3.0
+ * @link     http://status.net/
+ */
+
 class TableDef
 {
+    /** name of the table */
     public $name;
+    /** array of ColumnDef objects for the columns. */
     public $columns;
 }
 
+/**
+ * A class encapsulating the structure of a column in a table.
+ *
+ * @category Database
+ * @package  StatusNet
+ * @author   Evan Prodromou <evan@status.net>
+ * @license  http://www.fsf.org/licensing/licenses/agpl-3.0.html GNU Affero General Public License version 3.0
+ * @link     http://status.net/
+ */
+
 class ColumnDef
 {
+    /** name of the column. */
     public $name;
+    /** type of column, e.g. 'int', 'varchar' */
     public $type;
+    /** size of the column. */
     public $size;
+    /** boolean flag; can it be null? */
     public $nullable;
+    /**
+     * type of key: null = no key; 'PRI' => primary;
+     * 'UNI' => unique key; 'MUL' => multiple values.
+     */
     public $key;
+    /** default value if any. */
     public $default;
+    /** 'extra' stuff. Returned by MySQL, largely
+     * unused. */
     public $extra;
 
+    /**
+     * Constructor.
+     *
+     * @param string  $name     name of the column
+     * @param string  $type     type of the column
+     * @param int     $size     size of the column
+     * @param boolean $nullable can this be null?
+     * @param string  $key      type of key
+     * @param value   $default  default value
+     * @param value   $extra    unused
+     */
+
     function __construct($name=null, $type=null, $size=null,
                          $nullable=true, $key=null, $default=null,
-                         $extra=null) {
+                         $extra=null)
+    {
         $this->name     = strtolower($name);
         $this->type     = strtolower($type);
         $this->size     = $size+0;
@@ -400,6 +602,15 @@ class ColumnDef
         $this->extra    = $extra;
     }
 
+    /**
+     * Compares this columndef with another to see
+     * if they're functionally equivalent.
+     *
+     * @param ColumnDef $other column to compare
+     *
+     * @return boolean true if equivalent, otherwise false.
+     */
+
     function equals($other)
     {
         return ($this->name == $other->name &&
@@ -409,37 +620,61 @@ class ColumnDef
                 $this->key == $other->key);
     }
 
-    function _typeMatch($other)
+    /**
+     * Does the type of this column match the
+     * type of the other column?
+     *
+     * Checks the type and size of a column. Tries
+     * to ignore differences between synonymous
+     * data types, like 'integer' and 'int'.
+     *
+     * @param ColumnDef $other other column to check
+     *
+     * @return boolean true if they're about equivalent
+     */
+
+    private function _typeMatch($other)
     {
         switch ($this->type) {
-         case 'integer':
-         case 'int':
+        case 'integer':
+        case 'int':
             return ($other->type == 'integer' ||
                     $other->type == 'int');
             break;
-         default:
+        default:
             return ($this->type == $other->type &&
                     $this->size == $other->size);
         }
     }
 
-    function _defaultMatch($other)
+    /**
+     * Does the default behaviour of this column match
+     * the other?
+     *
+     * @param ColumnDef $other other column to check
+     *
+     * @return boolean true if defaults are effectively the same.
+     */
+
+    private function _defaultMatch($other)
     {
         return ((is_null($this->default) && is_null($other->default)) ||
                 ($this->default == $other->default));
     }
 
-    function _nullMatch($other)
+    /**
+     * Does the null behaviour of this column match
+     * the other?
+     *
+     * @param ColumnDef $other other column to check
+     *
+     * @return boolean true if these columns 'null' the same.
+     */
+
+    private function _nullMatch($other)
     {
         return ((!is_null($this->default) && !is_null($other->default) &&
                  $this->default == $other->default) ||
                 ($this->nullable == $other->nullable));
     }
 }
-
-class IndexDef
-{
-    public $name;
-    public $table;
-    public $columns;
-}