modules/versioncontrol/versioncontrol.install

<?php
// $Id$
/**
 * @file
 * Version Control API - An interface to version control systems
 * whose functionality is provided by pluggable back-end modules.
 *
 * Copyright 2006 by Karthik ("Zen", http://drupal.org/user/21209)
 * Copyright 2006, 2007 by Derek Wright ("dww", http://drupal.org/user/46549)
 * Copyright 2007, 2008, 2009 by Jakob Petsovits ("jpetso", http://drupal.org/user/56020)
 */

/**
 * Implementation of hook_schema().
 */
function versioncontrol_schema() {
  $schema['versioncontrol_operations'] = array(
    'description' => 'The combined table for commit, branch and tag operations.',
    'fields' => array(
      'vc_op_id' => array(
        'description' => 'Unique identifier for each operation in this table. Does not necessarily correspond to chronological order in any way.',
        'type' => 'serial',
        'unsigned' => TRUE,
        'not null' => TRUE,
      ),
      'type' => array(
        'description' =>
          'Operation type as specified by the backend: either of VERSIONCONTROL_OPERATION_COMMIT, VERSIONCONTROL_OPERATION_BRANCH or VERSIONCONTROL_OPERATION_TAG. (For version control systems like Subversion that need to emulate branches and tags, this will still be VERSIONCONTROL_OPERATION_COMMIT - the "intended" meaning is stored as associated label action.)',
        'type' => 'int',
        'size' => 'tiny',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
      'repo_id' => array(
        'description' => 'Foreign key (referring to {versioncontrol_repositories}.repo_id) for the repository that was affected by the operation.',
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
      'date' => array(
        'description' => 'Date/time when the operation was executed, as Unix timestamp.',
        'type' => 'int',
        'size' => 'big',
        'not null' => TRUE,
        'default' => 0,
      ),
      'uid' => array(
        'description' =>
          'The {users}.uid for the Drupal user corresponding to the VCS-specific username in {versioncontrol_operations}.username, if such an association can be found. 0 otherwise. (The account associations are retrieved from the {versioncontrol_accounts} table.',
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
      'author' => array(
        'description' => 'VCS specific username of the user who is the original author of this operation. For centralized version control systems this and committer are the same.',
        'type' => 'varchar',
        'length' => 64,
        'not null' => TRUE,
        'default' => '',
      ),
      'committer' => array(
        'description' => 'VCS specific username of the user who executed this operation. For distributed version control systems, this should be the author, not the committer. For centralized version control systems this and author are the same.',
        'type' => 'varchar',
        'length' => 64,
        'not null' => TRUE,
        'default' => '',
      ),
      'revision' => array(
        'description' =>
          'VCS specific global revision identifier, like "1234" for Subversion or some SHA-1 hash for various distributed version control systems. Empty string if the VCS does not support atomic commits / global revisions.',
        'type' => 'varchar',
        'length' => 255,
        'not null' => TRUE,
        'default' => '',
      ),
      'message' => array(
        'description' =>
          'Log message. Might be empty for branch and tag operations, depending on the version control system\'s capabilities. Should really not be empty for commit messages, except for the super-evil case when the commit author is sloppy enough not to enter one *and* the VCS allows that to happen.',
        'type' => 'text',
        'not null' => FALSE,
      ),
    ),
    'indexes' => array(
      'type' => array('type'),
      'repo_id' => array('repo_id'),
      'date' => array('date'),
      'uid' => array('uid'),
      'author' => array('author'),
      'committer' => array('committer'),
      'revision' => array('revision'),
    ),
    'primary key' => array('vc_op_id'),
  );

  $schema['versioncontrol_operation_labels'] = array(
    'description' =>
      'This table contains information about which branches and/or tags (= labels, referred to by the label_id) have been affected by an operation (vc_op_id), and how they\'ve been affected (action). Let\'s refer to that combination as "label action".

      Commit operations might not have any label associated, which happens e.g. for SVN commits outside of /trunk, /tags and /branches (or if labels are neither natively supported nor emulated).

      Possible label actions are:
      - Commit: commit operation, label is a branch, action == VERSIONCONTROL_ACTION_MODIFIED
      - Native branch/tag creation: branch or tag operation, label has the
          same type as the operation, action == VERSIONCONTROL_ACTION_ADDED
      - Native branch/tag deletion: branch or tag operation, label has the
          same type as the operation, action == VERSIONCONTROL_ACTION_DELETED
      - Emulated branch/tag creation or deletion (think of SVN branches and
          tags): commit operation, any label type, action is the same as for
          native creations/deletions.',
    'fields' => array(
      'vc_op_id' => array(
        'description' => 'Foreign key (referring to {versioncontrol_operations}.vc_op_id) for the operation that affected the given label(s).',
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
      'label_id' => array(
        'description' => 'Foreign key (referring to {versioncontrol_labels}.label_id) for the affected label.',
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
      'action' => array(
        'description' =>
          'Specifies how the label was affected, see the {versioncontrol_operation_labels} table description for details on the semantics. Possible values are VERSIONCONTROL_ACTION_MODIFIED, VERSIONCONTROL_ACTION_ADDED and VERSIONCONTROL_ACTION_DELETED.',
        'type' => 'int',
        'size' => 'tiny',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
    ),
    'primary key' => array('vc_op_id', 'label_id'),
  );

  $schema['versioncontrol_labels'] = array(
    'description' =>
      'This table stores information about branches and tags (= labels) that exist in a repository. While there might be multiple operations involving the same branch/tag (see also {versioncontrol_operation_labels}, e.g. "create DRUPAL-6--1-0 tag for the files in project 1", "create DRUPAL-6--1-0 tag for the files in project 2", "delete DRUPAL-6--1-0 tag for the files in project 2 again"), there is only one row in this table that represents this label ("DRUPAL-6--1-0" in the above example).',
    'fields' => array(
      'label_id' => array(
        'description' => 'Unique identifier for a branch or tag in this label, equivalent to the (also unique) repo_id/name/type combination in the same row.',
        'type' => 'serial',
        'unsigned' => TRUE,
        'not null' => TRUE,
      ),
      'repo_id' => array(
        'description' => 'Foreign key (referring to {versioncontrol_repositories}.repo_id) for the repository that this label is located in.',
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
      'name' => array(
        'description' => 'Name of the label, e.g. "HEAD", "master", "DRUPAL-6--1" or "6.x-1.0".',
        'type' => 'varchar',
        'length' => 255,
        'not null' => TRUE,
        'default' => '',
      ),
      'type' => array(
        'description' =>
          'Whether this label is a branch or a tag. Consequently, this can be either VERSIONCONTROL_LABEL_BRANCH or VERSIONCONTROL_LABEL_TAG.',
        'type' => 'int',
        'size' => 'tiny',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
    ),
    'unique keys' => array(
      'repo_id_name_type' => array('repo_id', 'name', 'type'),
    ),
    'primary key' => array('label_id'),
  );

  $schema['versioncontrol_operation_items'] = array(
    'description' =>
      'This table relates an operation to the items (or more correctly, to the item revisions) that it affected. For example, an SVN commit with revision "1234" might modify an item that is now /trunk/file.txt at revision "1234", and move a directory from somewhere else that is now /trunk/dir at revision "1234". Those items are recorded here along with the vc_op_id that describes the general operation properties.

      Branch/tag operations that affect the whole repository (like in Git or Mercurial) do not have items associated, whereas branch/tag operations that affect only a limited set of items (like in CVS or Subversion) link to the branched/tagged items with this table.',
    'fields' => array(
      'vc_op_id' => array(
        'description' => 'Foreign key (referring to {versioncontrol_operations}.vc_op_id) for the operation that affected the given item(s).',
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
      'item_revision_id' => array(
        'description' => 'Foreign key (referring to {versioncontrol_item_revisions}.item_revision_id) for the affected item revision.',
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
      'type' => array(
        'description' =>
          'Real member or cached item. This is an implementation detail of a performance optimization (for queries with a "paths" constraint), and private to the API module. Other modules must not touch this. VERSIONCONTROL_OPERATION_MEMBER_ITEM is the standard value and makes up for most entries in here, whereas VERSIONCONTROL_OPERATION_CACHED_AFFECTED_ITEM is the optimization (denoting an item that is not part of a VersioncontrolOperation::getItems() result but will still cause that operation to be found if it matches the "paths" constraint).',
        'type' => 'int',
        'size' => 'tiny',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
    ),
    'indexes' => array(
      'type' => array('type'),
    ),
    'primary key' => array('vc_op_id', 'item_revision_id'),
  );

  $schema['versioncontrol_source_items'] = array(
    'description' =>
      'This table stores item history, i.e. it relates an item to one or more direct predecessors (= source items). Likewise, a source item can also have multiple successors, for example if it\'s copied to one location and later (or at the same time) moved to another location.',
    'fields' => array(
      'item_revision_id' => array(
        'description' =>
          'Foreign key for the successor item, referring to {versioncontrol_item_revisions}.item_revision_id. This one is more recent in revision history than the source item.',
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
      'source_item_revision_id' => array(
        'description' =>
          'Foreign key for the source item - also referring to {versioncontrol_item_revisions}.item_revision_id, but to a different one than the above {versioncontrol_source_items}.item_revision_id. Contains 0 if the action is VERSIONCONTROL_ACTION_ADDED.',
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
      'action' => array(
        'description' =>
          'Action that was performed while transforming the source item into the successor item. Can be one of the VERSIONCONTROL_ACTION_* values listed at the top of versioncontrol.module.

          The VERSIONCONTROL_ACTION_DELETED and VERSIONCONTROL_ACTION_REPLACED actions are considered to be the end in the history of an item, no further successors than the current one should be retrieved. (For VERSIONCONTROL_ACTION_DELETED, item_revision_id links to a deleted item. For VERSIONCONTROL_ACTION_REPLACED, item_revision_id links to a different item at the same path that replaced the item specified by source_item_revision_id.

          Likewise, the VERSIONCONTROL_ACTION_ADDED action is considered the beginning, with source_item_revision_id being 0 in that case.',
        'type' => 'int',
        'size' => 'tiny',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
      'line_changes_recorded' => array(
        'description' =>
          'Specifies whether line-change information is available (1 as value) or not (0 as value). Naturally, this should only apply to file items, not to directory items. VERSIONCONTROL_ACTION_DELETED and VERSIONCONTROL_ACTION_REPLACED actions are also not supposed to contain line-change information.',
        'type' => 'int',
        'size' => 'tiny',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
      'line_changes_added' => array(
        'description' =>
          'If the line_changes_recorded column is 1 then this column contains the amount of lines that was added to the file compared to its source revision. (Equivalent to the "plus" lines in a unified diff.)',
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
      'line_changes_removed' => array(
        'description' =>
          'If the line_changes_recorded column is 1 then this column contains the amount of lines that was removed from the file compared to its source revision. (Equivalent to the "minus" lines in a unified diff.)',
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
    ),
    'primary key' => array('item_revision_id', 'source_item_revision_id'),
  );

  $schema['versioncontrol_item_revisions'] = array(
    'description' =>
      'This table contains all known different versions of a file or directory item. For version control systems using global revisions, only the revisions should be recorded in here when the item was actually changed, i.e. part of a commit operation. (Not every revision needs to have all associated items recorded in here, that would be insane.) Non-versioned items, such as directories in CVS or Git, should not be recorded in this table.',
    'fields' => array(
      'item_revision_id' => array(
        'description' =>
          'Unique identifier for this item revision. The same item in a different revision gets a different item_revision_id. Equivalent to the (also unique) repo_id/path/revision combination in the same row.',
        'type' => 'serial',
        'unsigned' => TRUE,
        'not null' => TRUE,
      ),
      'repo_id' => array(
        'description' => 'Foreign key (referring to {versioncontrol_repositories}.repo_id) for the repository that this item is located in.',
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
      'path' => array(
        'description' =>
          'Path of the item, relative to the repository root. Always starts with a slash, and never ends with one (not even if the item is a directory). Examples: "/" (root directory), "/contributions", "/sandbox/jpetso/evil-plans.txt". The slash is only used for separating the parts of the path, so it is safe to use explode("/", $path).',
        'type' => 'varchar',
        'length' => 255,
        'not null' => TRUE,
        'default' => '',
      ),
      'revision' => array(
        'description' =>
          '(File-level) revision of the item, such as "1.12.4.3" for CVS. If the version control system supports global revisions, this should contain the same revision as the "revision" property of the associated commit operation. Contrary to {versioncontrol_operations}.revision which may be empty, this column must always contain a revision because every changed item has a revision assigned. (If it lacks a revision, it should not be recorded as operation item in the first place.)',
        'type' => 'varchar',
        'length' => 255,
        'not null' => TRUE,
        'default' => '',
      ),
      'type' => array(
        'description' =>
          'Specifies whether the item is a file or directory, and whether it exists or is deleted. Deleted items might exist for real, such as in CVS repositories (the "Attic") or they might just be recorded as part of a commit operation where the item was deleted, even though the version control system does not know about this revision. In Version Control API, deleted items only exist for display purposes, backends are expected not to retrieve information about them other than item history. Possible values for the item type are VERSIONCONTROL_ITEM_FILE, VERSIONCONTROL_ITEM_FILE_DELETED, VERSIONCONTROL_ITEM_DIRECTORY and VERSIONCONTROL_ITEM_DIRECTORY_DELETED. Usually though, API users should only use the functions VersioncontrolItem::isFile(), VersioncontrolItem::isDirectory() and VersioncontrolItem::isDeleted() for testing these constants.',
        'type' => 'int',
        'size' => 'tiny',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
    ),
    // Key too long, cannot create an index for this unique key.
    //'unique keys' => array(
    //  'repo_id_path_revision' => array('repo_id', 'path', 'revision'),
    //),
    // So instead, we roll two separate indexes.
    'indexes' => array(
      'repo_id_path' => array('repo_id', 'path'),
      'revision' => array('revision'),
    ),
    'primary key' => array('item_revision_id'),
  );

  $schema['versioncontrol_repositories'] = array(
    'description' => 'This table contains the set of repositories known to the Version Control API.',
    'fields' => array(
      'repo_id' => array(
        'description' => 'Primary key, the unique identifier for the repository.',
        'type' => 'serial',
        'unsigned' => TRUE,
        'not null' => TRUE,
      ),
      'name' => array(
        'description' => 'User visible name of the repository, to be run through check_plain().',
        'type' => 'varchar',
        'length' => 255,
        'not null' => TRUE,
        'default' => '',
      ),
      'vcs' => array(
        'description' => 'Unique string identifier of the backend, e.g. "cvs", "svn" or "git".',
        'type' => 'varchar',
        'length' => 8,
        'not null' => TRUE,
        'default' => '',
      ),
      'root' => array(
        'description' => 'Root URL/path of the repository, to be interpreted by the VCS backend when it interfaces with the repository.',
        'type' => 'varchar',
        'length' => 255,
        'not null' => TRUE,
        'default' => '',
      ),
      'authorization_method' => array(
        'description' => 'Unique string identifier of the authorization method. (For more information on authorization methods, see hook_versioncontrol.php for functions marked with "@ingroup Authorization".)',
        'type' => 'varchar',
        'length' => 64,
        'not null' => TRUE,
        'default' => '',
      ),
      'data' => array(
        'description' => t('A serialized array of additional per-repository settings, mostly populated by third-party modules.'),
        'type' => 'text',
        'size' => 'medium',
        'not null' => TRUE,
        'serialize' => TRUE,
      ),
    ),
    'unique keys' => array(
      'name' => array('name'),
    ),
    'primary key' => array('repo_id'),
  );

  $schema['versioncontrol_accounts'] = array(
    'description' =>
      'Association table of VCS account usernames (in a specific repository) to Drupal user ids. A Drupal user can be associated to multiple VCS accounts. Ideally, multiple VCS accounts per repository should be possible too, but clumsy array data structures and assumptions in the admin interface (elsewhere, too? don\'t know) currently make it necessary to restrict the number of VCS accounts to a maximum of 1 per repository and Drupal user.',
    'fields' => array(
      'uid' => array(
        'description' => 'The {users}.uid of the Drupal user associated with the VCS-specific username in {versioncontrol_accounts}.username.',
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
      'repo_id' => array(
        'description' => 'Foreign key (referring to {versioncontrol_repositories}.repo_id) for the repository that contains the VCS account.',
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
      ),
      'username' => array(
        'description' => 'VCS-specific username of the VCS account associated with the Drupal user in {versioncontrol_accounts}.uid.',
        'type' => 'varchar',
        'length' => 64,
        'not null' => TRUE,
        'default' => '',
      ),
    ),
    'unique keys' => array(
      'repo_id_username' => array('repo_id', 'username'),
    ),
    'primary key' => array('uid', 'repo_id'),
  );

  return $schema;
}

/**
 * Implementation of hook_install().
 */
function versioncontrol_install() {
  // Create tables.
  drupal_install_schema('versioncontrol');
}

/**
 * Implementation of hook_uninstall().
 */
function versioncontrol_uninstall() {
  $variables = array(
    'versioncontrol_email_address',
    'versioncontrol_registration_message_unauthorized',
    'versioncontrol_registration_message_authorized',
    'versioncontrol_admin_account_pager',
  );
  foreach ($variables as $variable) {
    variable_del($variable);
  }

  // Remove tables.
  drupal_uninstall_schema('versioncontrol');
}


// Update functions. To be named versioncontrol_update_xyzz(), where x is the
// major version of Drupal core, y is the major version of Version Control API
// for this version of Drupal core, and zz is a consecutive number.

// versioncontrol_update_9() was the last update on Drupal 5.x (-2.x).

/**
 * Original update from 5.x-2.x to 6.x-2.x:
 * Change 5.x pure integer types to 6.x serial types.
 */
function versioncontrol_update_6100() {
  $ret = array();

  // Auto-increment fields don't like 0 values.
  // So let's remove the "empty" item and implement it in some other way.
  $ret = update_sql('DELETE FROM {versioncontrol_item_revisions}
                      WHERE item_revision_id = 0');

  db_drop_primary_key($ret, 'versioncontrol_operations');
  db_change_field($ret, 'versioncontrol_operations', 'vc_op_id', 'vc_op_id',
    array('type' => 'serial', 'unsigned' => TRUE, 'not null' => TRUE),
    array('primary key' => array('vc_op_id'))
  );
  db_drop_primary_key($ret, 'versioncontrol_labels');
  db_change_field($ret, 'versioncontrol_labels', 'label_id', 'label_id',
    array('type' => 'serial', 'unsigned' => TRUE, 'not null' => TRUE),
    array('primary key' => array('label_id'))
  );
  db_drop_primary_key($ret, 'versioncontrol_item_revisions');
  db_change_field($ret, 'versioncontrol_item_revisions', 'item_revision_id', 'item_revision_id',
    array('type' => 'serial', 'unsigned' => TRUE, 'not null' => TRUE),
    array('primary key' => array('item_revision_id'))
  );
  db_drop_primary_key($ret, 'versioncontrol_repositories');
  db_change_field($ret, 'versioncontrol_repositories', 'repo_id', 'repo_id',
    array('type' => 'serial', 'unsigned' => TRUE, 'not null' => TRUE),
    array('primary key' => array('repo_id'))
  );

  return $ret;
}

/**
 * Update from 6.x-1.0-rc1 to rc2:
 * String deltas for the "active developers" block.
 */
function versioncontrol_update_6101() {
  $ret = array();
  $ret[] = update_sql("
    UPDATE {blocks} SET delta = 'site_active_developers'
    WHERE delta = '0' AND module = 'versioncontrol'");
  return $ret;
}

/**
 * Update from 6.x-1.0-rc2 to 6.x-1.0-rc3:
 * Add a "data" column for modules to put their per-repository settings,
 * and migrate the registration texts as well as the previously global option
 * "allow unauthorized commit access" to the data column for all repositories.
 *
 * Per-repository settings of the Commit Restrictions module is also migrated
 * in this function - for convenience, as otherwise we would need some extra
 * logic to prevent its updates as long as the data column doesn't yet exist.
 */
function versioncontrol_update_6102() {
  $ret = array();
  $spec = array(
    'description' => t('A serialized array of additional per-repository settings, mostly populated by third-party modules.'),
    'type' => 'text',
    'size' => 'medium',
    'not null' => TRUE,
    'serialize' => TRUE,
  );
  db_add_field($ret, 'versioncontrol_repositories', 'data', $spec);

  $global_access = (bool) variable_get('versioncontrol_allow_unauthorized_access', 0);
  $data_template = array(
    'versioncontrol' => array('allow_unauthorized_access' => $global_access),
  );

  // Get all repository ids. Some of the data arrays might get changed still,
  // so we don't write them all at once.
  $result = db_query('
    SELECT r.repo_id, m.registration_message
    FROM {versioncontrol_repositories} r
      LEFT JOIN {versioncontrol_repository_metadata} m
        ON r.repo_id = m.repo_id'
  );
  while ($repository = db_fetch_object($result)) {
    $repository_data[$repository->repo_id] = $data_template;
    $repository_data[$repository->repo_id]['versioncontrol']['registration_message'] =
      $repository->registration_message;
  }

  // Migrate Commit Restrictions module settings into the $data array,
  // and delete the module's table after all data has been migrated.
  if (db_table_exists('commit_restrictions')) {
    $result = db_query('
      SELECT repo_id, allowed_paths, forbidden_paths, deny_undefined_paths,
        valid_branch_tag_paths, valid_branches, valid_tags
      FROM {commit_restrictions}'
    );

    while ($restrictions = db_fetch_array($result)) {
      $repo_id = $restrictions['repo_id'];

      $restrictions = array_filter(array(
        'allowed_paths'          => array_filter(explode(' ', $restrictions['allowed_paths'])),
        'forbidden_paths'        => array_filter(explode(' ', $restrictions['forbidden_paths'])),
        'valid_branch_tag_paths' => array_filter(explode(' ', $restrictions['valid_branch_tag_paths'])),
        'valid_branches'         => array_filter(explode(' ', $restrictions['valid_branches'])),
        'valid_tags'             => array_filter(explode(' ', $restrictions['valid_tags'])),
      ));
      if (!empty($restrictions['deny_undefined_paths'])) {
        $restrictions['deny_undefined_paths'] = (bool) $restrictions['deny_undefined_paths'];
      }
      if (!empty($restrictions)) {
        $repository_data[$repo_id]['commit_restrictions'] = $restrictions;
      }
    }
    db_drop_table($ret, 'commit_restrictions');
  }

  // Write the $data array to the respective repositories.
  foreach ($repository_data as $repo_id => $data) {
    $ret[] = update_sql("UPDATE {versioncontrol_repositories}
                          SET data = '". db_escape_string(serialize($data)) ."'
                          WHERE repo_id = ". $repo_id);
  }

  db_drop_table($ret, 'versioncontrol_repository_metadata');
  variable_del('versioncontrol_allow_unauthorized_access');

  $ret[] = array(
    'success' => TRUE,
    'query' => 'Deleted the global "versioncontrol_allow_unauthorized_access" variable, and migrated it to be a per-repository setting.',
  );

  return $ret;
}

/**
 * Update 6300 (from 6.x-2.0 to 6.x-3.0):
 * Adding author and commiter instead of only username
 * Move urls to data array.
 * Drop url_backend field from repo table
 */
function versioncontrol_update_6300() {
  $ret = array();

  // author and committer
  $author_spec = array(
    'description' => 'VCS specific username of the user who is the original author of this operation. For centralized version control systems this and committer are the same.',
    'type' => 'varchar',
    'length' => 64,
    'not null' => TRUE,
    'default' => '',
  );
  $committer_spec = array(
    'description' => 'VCS specific username of the user who executed this operation. For distributed version control systems, this should be the author, not the committer. For centralized version control systems this and author are the same.',
    'type' => 'varchar',
    'length' => 64,
    'not null' => TRUE,
    'default' => '',
  );
  db_change_field($ret, 'versioncontrol_operations', 'username', 'author', $author_spec);
  db_add_field($ret, 'versioncontrol_operations', 'committer', $committer_spec);

  // urls to data array
  $repos = VersioncontrolRepositoryCache::getInstance()->getAllRepositories();
  $result = db_query('SELECT * FROM {versioncontrol_repository_urls}');
  while ($urls = db_fetch_array($result)) {
    $repo_id = $urls['repo_id'];
    unset($urls['repo_id']);
    $repos[$repo_id]->data['versioncontrol']['url_handler'] = new VersioncontrolRepositoryUrlHandler($repos[$repo_id], $urls);
    $repos[$repo_id]->update();
  }
  db_drop_table($ret, 'versioncontrol_repository_urls');

  // no more url backend
  db_drop_field($ret, 'versioncontrol_repositories', 'url_backend');

  return $ret;
}