PHP PhabricatorRepository::getCallsign方法代码示例

 public function processRequest()
 {
     $request = $this->getRequest();
     $user = $request->getUser();
     $e_name = true;
     $e_callsign = true;
     $repository = new PhabricatorRepository();
     $type_map = PhabricatorRepositoryType::getAllRepositoryTypes();
     $errors = array();
     if ($request->isFormPost()) {
         $repository->setName($request->getStr('name'));
         $repository->setCallsign($request->getStr('callsign'));
         $repository->setVersionControlSystem($request->getStr('type'));
         if (!strlen($repository->getName())) {
             $e_name = 'Required';
             $errors[] = 'Repository name is required.';
         } else {
             $e_name = null;
         }
         if (!strlen($repository->getCallsign())) {
             $e_callsign = 'Required';
             $errors[] = 'Callsign is required.';
         } else {
             if (!preg_match('/^[A-Z]+$/', $repository->getCallsign())) {
                 $e_callsign = 'Invalid';
                 $errors[] = 'Callsign must be ALL UPPERCASE LETTERS.';
             } else {
                 $e_callsign = null;
             }
         }
         if (empty($type_map[$repository->getVersionControlSystem()])) {
             $errors[] = 'Invalid version control system.';
         }
         if (!$errors) {
             try {
                 $repository->save();
                 return id(new AphrontRedirectResponse())->setURI('/repository/edit/' . $repository->getID() . '/');
             } catch (AphrontQueryDuplicateKeyException $ex) {
                 $e_callsign = 'Duplicate';
                 $errors[] = 'Callsign must be unique. Another repository already ' . 'uses that callsign.';
             }
         }
     }
     $error_view = null;
     if ($errors) {
         $error_view = new AphrontErrorView();
         $error_view->setErrors($errors);
         $error_view->setTitle('Form Errors');
     }
     $form = new AphrontFormView();
     $form->setUser($user)->setAction('/repository/create/')->appendChild(id(new AphrontFormTextControl())->setLabel('Name')->setName('name')->setValue($repository->getName())->setError($e_name)->setCaption('Human-readable repository name.'))->appendChild('<p class="aphront-form-instructions">Select a "Callsign" &mdash; a ' . 'short, uppercase string to identify revisions in this repository. If ' . 'you choose "EX", revisions in this repository will be identified ' . 'with the prefix "rEX".</p>')->appendChild(id(new AphrontFormTextControl())->setLabel('Callsign')->setName('callsign')->setValue($repository->getCallsign())->setError($e_callsign)->setCaption('Short, UPPERCASE identifier. Once set, it can not be changed.'))->appendChild(id(new AphrontFormSelectControl())->setLabel('Type')->setName('type')->setOptions($type_map)->setValue($repository->getVersionControlSystem()))->appendChild(id(new AphrontFormSubmitControl())->setValue('Create Repository')->addCancelButton('/repository/'));
     $panel = new AphrontPanelView();
     $panel->setHeader('Create Repository');
     $panel->appendChild($form);
     $panel->setWidth(AphrontPanelView::WIDTH_FORM);
     return $this->buildStandardPageResponse(array($error_view, $panel), array('title' => 'Create Repository'));
 }

 public static final function nameCommit(PhabricatorRepository $repository, $commit)
 {
     switch ($repository->getVersionControlSystem()) {
         case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
             $commit_name = substr($commit, 0, 12);
             break;
         default:
             $commit_name = $commit;
             break;
     }
     $callsign = $repository->getCallsign();
     return "r{$callsign}{$commit_name}";
 }

 protected function parseCommit(PhabricatorRepository $repository, PhabricatorRepositoryCommit $commit)
 {
     $identifier = $commit->getCommitIdentifier();
     $callsign = $repository->getCallsign();
     $full_name = 'r' . $callsign . $identifier;
     $this->log("Parsing %s...\n", $full_name);
     if ($this->isBadCommit($full_name)) {
         $this->log('This commit is marked bad!');
         return;
     }
     $results = $this->parseCommitChanges($repository, $commit);
     if ($results) {
         $this->writeCommitChanges($repository, $commit, $results);
     }
     $this->finishParse();
 }

 private function isCommitOnBranch(PhabricatorRepository $repo, PhabricatorRepositoryCommit $commit, ReleephBranch $releeph_branch)
 {
     switch ($repo->getVersionControlSystem()) {
         case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
             list($output) = $repo->execxLocalCommand('branch --all --no-color --contains %s', $commit->getCommitIdentifier());
             $remote_prefix = 'remotes/origin/';
             $branches = array();
             foreach (array_filter(explode("\n", $output)) as $line) {
                 $tokens = explode(' ', $line);
                 $ref = last($tokens);
                 if (strncmp($ref, $remote_prefix, strlen($remote_prefix)) === 0) {
                     $branch = substr($ref, strlen($remote_prefix));
                     $branches[$branch] = $branch;
                 }
             }
             return idx($branches, $releeph_branch->getName());
             break;
         case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
             $change_query = DiffusionPathChangeQuery::newFromDiffusionRequest(DiffusionRequest::newFromDictionary(array('user' => $this->getUser(), 'repository' => $repo, 'commit' => $commit->getCommitIdentifier())));
             $path_changes = $change_query->loadChanges();
             $commit_paths = mpull($path_changes, 'getPath');
             $branch_path = $releeph_branch->getName();
             $in_branch = array();
             $ex_branch = array();
             foreach ($commit_paths as $path) {
                 if (strncmp($path, $branch_path, strlen($branch_path)) === 0) {
                     $in_branch[] = $path;
                 } else {
                     $ex_branch[] = $path;
                 }
             }
             if ($in_branch && $ex_branch) {
                 $error = pht('CONFUSION: commit %s in %s contains %d path change(s) that were ' . 'part of a Releeph branch, but also has %d path change(s) not ' . 'part of a Releeph branch!', $commit->getCommitIdentifier(), $repo->getCallsign(), count($in_branch), count($ex_branch));
                 phlog($error);
             }
             return !empty($in_branch);
             break;
     }
 }

 protected function parseCommit(PhabricatorRepository $repository, PhabricatorRepositoryCommit $commit)
 {
     $full_name = 'r' . $repository->getCallsign() . $commit->getCommitIdentifier();
     echo "Parsing {$full_name}...\n";
     if ($this->isBadCommit($full_name)) {
         echo "This commit is marked bad!\n";
         return;
     }
     list($stdout) = $repository->execxLocalCommand('status -C --change %s', $commit->getCommitIdentifier());
     $status = ArcanistMercurialParser::parseMercurialStatusDetails($stdout);
     $common_attributes = array('repositoryID' => $repository->getID(), 'commitID' => $commit->getID(), 'commitSequence' => $commit->getEpoch());
     $changes = array();
     // Like Git, Mercurial doesn't track directories directly. We need to infer
     // directory creation and removal by observing file creation and removal
     // and testing if the directories in question are previously empty (thus,
     // created) or subsequently empty (thus, removed).
     $maybe_new_directories = array();
     $maybe_del_directories = array();
     $all_directories = array();
     // Parse the basic information from "hg status", which shows files that
     // were directly affected by the change.
     foreach ($status as $path => $path_info) {
         $path = '/' . $path;
         $flags = $path_info['flags'];
         $change_target = $path_info['from'] ? '/' . $path_info['from'] : null;
         $changes[$path] = array('path' => $path, 'isDirect' => true, 'targetPath' => $change_target, 'targetCommitID' => $change_target ? $commit->getID() : null, 'changeType' => null, 'fileType' => null, 'flags' => $flags) + $common_attributes;
         if ($flags & ArcanistRepositoryAPI::FLAG_ADDED) {
             $maybe_new_directories[] = dirname($path);
         } else {
             if ($flags & ArcanistRepositoryAPI::FLAG_DELETED) {
                 $maybe_del_directories[] = dirname($path);
             }
         }
         $all_directories[] = dirname($path);
     }
     // Add change information for each source path which doesn't appear in the
     // status. These files were copied, but were not modified. We also know they
     // must exist.
     foreach ($changes as $path => $change) {
         $from = $change['targetPath'];
         if ($from && empty($changes[$from])) {
             $changes[$from] = array('path' => $from, 'isDirect' => false, 'targetPath' => null, 'targetCommitID' => null, 'changeType' => DifferentialChangeType::TYPE_COPY_AWAY, 'fileType' => null, 'flags' => 0) + $common_attributes;
         }
     }
     $away = array();
     foreach ($changes as $path => $change) {
         $target_path = $change['targetPath'];
         if ($target_path) {
             $away[$target_path][] = $path;
         }
     }
     // Now that we have all the direct changes, figure out change types.
     foreach ($changes as $path => $change) {
         $flags = $change['flags'];
         $from = $change['targetPath'];
         if ($from) {
             $target = $changes[$from];
         } else {
             $target = null;
         }
         if ($flags & ArcanistRepositoryAPI::FLAG_ADDED) {
             if ($target) {
                 if ($target['flags'] & ArcanistRepositoryAPI::FLAG_DELETED) {
                     $change_type = DifferentialChangeType::TYPE_MOVE_HERE;
                 } else {
                     $change_type = DifferentialChangeType::TYPE_COPY_HERE;
                 }
             } else {
                 $change_type = DifferentialChangeType::TYPE_ADD;
             }
         } else {
             if ($flags & ArcanistRepositoryAPI::FLAG_DELETED) {
                 if (isset($away[$path])) {
                     if (count($away[$path]) > 1) {
                         $change_type = DifferentialChangeType::TYPE_MULTICOPY;
                     } else {
                         $change_type = DifferentialChangeType::TYPE_MOVE_AWAY;
                     }
                 } else {
                     $change_type = DifferentialChangeType::TYPE_DELETE;
                 }
             } else {
                 if (isset($away[$path])) {
                     $change_type = DifferentialChangeType::TYPE_COPY_AWAY;
                 } else {
                     $change_type = DifferentialChangeType::TYPE_CHANGE;
                 }
             }
         }
         $changes[$path]['changeType'] = $change_type;
     }
     // Go through all the affected directories and identify any which were
     // actually added or deleted.
     $dir_status = array();
     foreach ($maybe_del_directories as $dir) {
         $exists = false;
         foreach (DiffusionPathIDQuery::expandPathToRoot($dir) as $path) {
             if (isset($dir_status[$path])) {
                 break;
             }
//.........这里部分代码省略.........

 private function getHookContextIdentifier(PhabricatorRepository $repository)
 {
     $identifier = $repository->getCallsign();
     $instance = PhabricatorEnv::getEnvConfig('cluster.instance');
     if (strlen($instance)) {
         $identifier = "{$identifier}:{$instance}";
     }
     return $identifier;
 }

 public function loadEditorLink($path, $line, PhabricatorRepository $repository = null)
 {
     $editor = $this->loadPreferences()->getPreference(PhabricatorUserPreferences::PREFERENCE_EDITOR);
     if (is_array($path)) {
         $multiedit = $this->loadPreferences()->getPreference(PhabricatorUserPreferences::PREFERENCE_MULTIEDIT);
         switch ($multiedit) {
             case '':
                 $path = implode(' ', $path);
                 break;
             case 'disable':
                 return null;
         }
     }
     if (!strlen($editor)) {
         return null;
     }
     if ($repository) {
         $callsign = $repository->getCallsign();
     } else {
         $callsign = null;
     }
     $uri = strtr($editor, array('%%' => '%', '%f' => phutil_escape_uri($path), '%l' => phutil_escape_uri($line), '%r' => phutil_escape_uri($callsign)));
     // The resulting URI must have an allowed protocol. Otherwise, we'll return
     // a link to an error page explaining the misconfiguration.
     $ok = PhabricatorHelpEditorProtocolController::hasAllowedProtocol($uri);
     if (!$ok) {
         return '/help/editorprotocol/';
     }
     return (string) $uri;
 }

 /**
  * Internal. Use @{method:newFromDictionary}, not this method.
  *
  * @param   PhabricatorRepository   Repository object.
  * @return  DiffusionRequest        New request object.
  * @task new
  */
 private static final function newFromRepository(PhabricatorRepository $repository)
 {
     $map = array(PhabricatorRepositoryType::REPOSITORY_TYPE_GIT => 'DiffusionGitRequest', PhabricatorRepositoryType::REPOSITORY_TYPE_SVN => 'DiffusionSvnRequest', PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL => 'DiffusionMercurialRequest');
     $class = idx($map, $repository->getVersionControlSystem());
     if (!$class) {
         throw new Exception("Unknown version control system!");
     }
     $object = new $class();
     $object->repository = $repository;
     $object->callsign = $repository->getCallsign();
     return $object;
 }

 /**
  * @task git
  */
 private function executeGitDiscover(PhabricatorRepository $repository)
 {
     list($remotes) = $repository->execxLocalCommand('remote show -n origin');
     $matches = null;
     if (!preg_match('/^\\s*Fetch URL:\\s*(.*?)\\s*$/m', $remotes, $matches)) {
         throw new Exception("Expected 'Fetch URL' in 'git remote show -n origin'.");
     }
     self::executeGitVerifySameOrigin($matches[1], $repository->getRemoteURI(), $repository->getLocalPath());
     list($stdout) = $repository->execxLocalCommand('branch -r --verbose --no-abbrev');
     $branches = DiffusionGitBranchQuery::parseGitRemoteBranchOutput($stdout, $only_this_remote = DiffusionBranchInformation::DEFAULT_GIT_REMOTE);
     $callsign = $repository->getCallsign();
     $tracked_something = false;
     $this->log("Discovering commits in repository '{$callsign}'...");
     foreach ($branches as $name => $commit) {
         $this->log("Examining branch '{$name}', at {$commit}.");
         if (!$repository->shouldTrackBranch($name)) {
             $this->log("Skipping, branch is untracked.");
             continue;
         }
         $tracked_something = true;
         if ($this->isKnownCommit($repository, $commit)) {
             $this->log("Skipping, HEAD is known.");
             continue;
         }
         $this->log("Looking for new commits.");
         $this->executeGitDiscoverCommit($repository, $commit, $name, false);
     }
     if (!$tracked_something) {
         $repo_name = $repository->getName();
         $repo_callsign = $repository->getCallsign();
         throw new Exception("Repository r{$repo_callsign} '{$repo_name}' has no tracked branches! " . "Verify that your branch filtering settings are correct.");
     }
     $this->log("Discovering commits on autoclose branches...");
     foreach ($branches as $name => $commit) {
         $this->log("Examining branch '{$name}', at {$commit}'.");
         if (!$repository->shouldTrackBranch($name)) {
             $this->log("Skipping, branch is untracked.");
             continue;
         }
         if (!$repository->shouldAutocloseBranch($name)) {
             $this->log("Skipping, branch is not autoclose.");
             continue;
         }
         if ($this->isKnownCommitOnAnyAutocloseBranch($repository, $commit)) {
             $this->log("Skipping, commit is known on an autoclose branch.");
             continue;
         }
         $this->log("Looking for new autoclose commits.");
         $this->executeGitDiscoverCommit($repository, $commit, $name, true);
     }
 }

 private function verifySubversionRoot(PhabricatorRepository $repository)
 {
     list($xml) = $repository->execxRemoteCommand('info --xml %s', $repository->getSubversionPathURI());
     $xml = phutil_utf8ize($xml);
     $xml = new SimpleXMLElement($xml);
     $remote_root = (string) $xml->entry[0]->repository[0]->root[0];
     $expect_root = $repository->getSubversionPathURI();
     $normal_type_svn = PhabricatorRepositoryURINormalizer::TYPE_SVN;
     $remote_normal = id(new PhabricatorRepositoryURINormalizer($normal_type_svn, $remote_root))->getNormalizedPath();
     $expect_normal = id(new PhabricatorRepositoryURINormalizer($normal_type_svn, $expect_root))->getNormalizedPath();
     if ($remote_normal != $expect_normal) {
         throw new Exception(pht('Repository "%s" does not have a correctly configured remote URI. ' . 'The remote URI for a Subversion repository MUST point at the ' . 'repository root. The root for this repository is "%s", but the ' . 'configured URI is "%s". To resolve this error, set the remote URI ' . 'to point at the repository root. If you want to import only part ' . 'of a Subversion repository, use the "Import Only" option.', $repository->getCallsign(), $remote_root, $expect_root));
     }
 }

 private function buildActionList(PhabricatorRepository $repository)
 {
     $viewer = $this->getRequest()->getUser();
     $view_uri = $this->getApplicationURI($repository->getCallsign() . '/');
     $edit_uri = $this->getApplicationURI($repository->getCallsign() . '/edit/');
     $view = id(new PhabricatorActionListView())->setUser($viewer)->setObject($repository)->setObjectURI($view_uri);
     $can_edit = PhabricatorPolicyFilter::hasCapability($viewer, $repository, PhabricatorPolicyCapability::CAN_EDIT);
     $view->addAction(id(new PhabricatorActionView())->setName(pht('Edit Repository'))->setIcon('fa-pencil')->setHref($edit_uri)->setWorkflow(!$can_edit)->setDisabled(!$can_edit));
     if ($repository->isHosted()) {
         $callsign = $repository->getCallsign();
         $push_uri = $this->getApplicationURI('pushlog/?repositories=r' . $callsign);
         $view->addAction(id(new PhabricatorActionView())->setName(pht('View Push Logs'))->setIcon('fa-list-alt')->setHref($push_uri));
     }
     return $view;
 }

 private function renderHeadsupActionList(PhabricatorRepositoryCommit $commit, PhabricatorRepository $repository)
 {
     $request = $this->getRequest();
     $user = $request->getUser();
     $actions = id(new PhabricatorActionListView())->setUser($user)->setObject($commit)->setObjectURI($request->getRequestURI());
     $can_edit = PhabricatorPolicyFilter::hasCapability($user, $commit, PhabricatorPolicyCapability::CAN_EDIT);
     $uri = '/diffusion/' . $repository->getCallsign() . '/commit/' . $commit->getCommitIdentifier() . '/edit/';
     $action = id(new PhabricatorActionView())->setName(pht('Edit Commit'))->setHref($uri)->setIcon('fa-pencil')->setDisabled(!$can_edit)->setWorkflow(!$can_edit);
     $actions->addAction($action);
     require_celerity_resource('phabricator-object-selector-css');
     require_celerity_resource('javelin-behavior-phabricator-object-selector');
     $maniphest = 'PhabricatorManiphestApplication';
     if (PhabricatorApplication::isClassInstalled($maniphest)) {
         $action = id(new PhabricatorActionView())->setName(pht('Edit Maniphest Tasks'))->setIcon('fa-anchor')->setHref('/search/attach/' . $commit->getPHID() . '/TASK/edge/')->setWorkflow(true)->setDisabled(!$can_edit);
         $actions->addAction($action);
     }
     $action = id(new PhabricatorActionView())->setName(pht('Download Raw Diff'))->setHref($request->getRequestURI()->alter('diff', true))->setIcon('fa-download');
     $actions->addAction($action);
     return $actions;
 }

 private static function buildDiffusionRequest(PhabricatorRepository $repository, PhabricatorRepositoryCommit $commit)
 {
     return DiffusionRequest::newFromAphrontRequestDictionary(array('callsign' => $repository->getCallsign(), 'commit' => $commit->getCommitIdentifier()));
 }

 protected function parseCommit(PhabricatorRepository $repository, PhabricatorRepositoryCommit $commit)
 {
     // PREAMBLE: This class is absurdly complicated because it is very difficult
     // to get the information we need out of SVN. The actual data we need is:
     //
     //  1. Recursively, what were the affected paths?
     //  2. For each affected path, is it a file or a directory?
     //  3. How was each path affected (e.g. add, delete, move, copy)?
     //
     // We spend nearly all of our effort figuring out (1) and (2) because
     // "svn log" is not recursive and does not give us file/directory
     // information (that is, it will report a directory move as a single move,
     // even if many thousands of paths are affected).
     //
     // Instead, we have to "svn ls -R" the location of each path in its previous
     // life to figure out whether it is a file or a directory and exactly which
     // recursive paths were affected if it was moved or copied. This is very
     // complicated and has many special cases.
     $uri = $repository->getDetail('remote-uri');
     $svn_commit = $commit->getCommitIdentifier();
     $callsign = $repository->getCallsign();
     $full_name = 'r' . $callsign . $svn_commit;
     echo "Parsing {$full_name}...\n";
     if ($this->isBadCommit($full_name)) {
         echo "This commit is marked bad!\n";
         return;
     }
     // Pull the top-level path changes out of "svn log". This is pretty
     // straightforward; just parse the XML log.
     $log = $this->getSVNLogXMLObject($uri, $svn_commit, $verbose = true);
     $entry = $log->logentry[0];
     if (!$entry->paths) {
         // TODO: Explicitly mark this commit as broken elsewhere? This isn't
         // supposed to happen but we have some cases like rE27 and rG935 in the
         // Facebook repositories where things got all clowned up.
         return;
     }
     $raw_paths = array();
     foreach ($entry->paths->path as $path) {
         $name = trim((string) $path);
         $raw_paths[$name] = array('rawPath' => $name, 'rawTargetPath' => (string) $path['copyfrom-path'], 'rawChangeType' => (string) $path['action'], 'rawTargetCommit' => (string) $path['copyfrom-rev']);
     }
     $copied_or_moved_map = array();
     $deleted_paths = array();
     $add_paths = array();
     foreach ($raw_paths as $path => $raw_info) {
         if ($raw_info['rawTargetPath']) {
             $copied_or_moved_map[$raw_info['rawTargetPath']][] = $raw_info;
         }
         switch ($raw_info['rawChangeType']) {
             case 'D':
                 $deleted_paths[$path] = $raw_info;
                 break;
             case 'A':
                 $add_paths[$path] = $raw_info;
                 break;
         }
     }
     // If a path was deleted, we need to look in the repository history to
     // figure out where the former valid location for it is so we can figure out
     // if it was a directory or not, among other things.
     $lookup_here = array();
     foreach ($raw_paths as $path => $raw_info) {
         if ($raw_info['rawChangeType'] != 'D') {
             continue;
         }
         // If a change copies a directory and then deletes something from it,
         // we need to look at the old location for information about the path, not
         // the new location. This workflow is pretty ridiculous -- so much so that
         // Trac gets it wrong. See Facebook rO6 for an example, if you happen to
         // work at Facebook.
         $parents = $this->expandAllParentPaths($path, $include_self = true);
         foreach ($parents as $parent) {
             if (isset($add_paths[$parent])) {
                 $relative_path = substr($path, strlen($parent));
                 $lookup_here[$path] = array('rawPath' => $add_paths[$parent]['rawTargetPath'] . $relative_path, 'rawCommit' => $add_paths[$parent]['rawTargetCommit']);
                 continue 2;
             }
         }
         // Otherwise we can just look at the previous revision.
         $lookup_here[$path] = array('rawPath' => $path, 'rawCommit' => $svn_commit - 1);
     }
     $lookup = array();
     foreach ($raw_paths as $path => $raw_info) {
         if ($raw_info['rawChangeType'] == 'D') {
             $lookup[$path] = $lookup_here[$path];
         } else {
             // For everything that wasn't deleted, we can just look it up directly.
             $lookup[$path] = array('rawPath' => $path, 'rawCommit' => $svn_commit);
         }
     }
     $path_file_types = $this->lookupPathFileTypes($repository, $lookup);
     $effects = array();
     $resolved_types = array();
     $supplemental = array();
     foreach ($raw_paths as $path => $raw_info) {
         if (isset($resolved_types[$path])) {
             $type = $resolved_types[$path];
         } else {
             switch ($raw_info['rawChangeType']) {
//.........这里部分代码省略.........

 protected function parseCommit(PhabricatorRepository $repository, PhabricatorRepositoryCommit $commit)
 {
     $full_name = 'r' . $repository->getCallsign() . $commit->getCommitIdentifier();
     echo "Parsing {$full_name}...\n";
     if ($this->isBadCommit($full_name)) {
         echo "This commit is marked bad!\n";
         return;
     }
     $local_path = $repository->getDetail('local-path');
     list($raw) = execx('(cd %s && git log -n1 -M -C -B --find-copies-harder --raw -t ' . '--abbrev=40 --pretty=format: %s)', $local_path, $commit->getCommitIdentifier());
     $changes = array();
     $move_away = array();
     $copy_away = array();
     $lines = explode("\n", $raw);
     foreach ($lines as $line) {
         if (!strlen(trim($line))) {
             continue;
         }
         list($old_mode, $new_mode, $old_hash, $new_hash, $more_stuff) = preg_split('/ +/', $line);
         // We may only have two pieces here.
         list($action, $src_path, $dst_path) = array_merge(explode("\t", $more_stuff), array(null));
         // Normalize the paths for consistency with the SVN workflow.
         $src_path = '/' . $src_path;
         if ($dst_path) {
             $dst_path = '/' . $dst_path;
         }
         $old_mode = intval($old_mode, 8);
         $new_mode = intval($new_mode, 8);
         $file_type = DifferentialChangeType::FILE_NORMAL;
         if ($new_mode & 040000) {
             $file_type = DifferentialChangeType::FILE_DIRECTORY;
         } else {
             if ($new_mode & 0120000) {
                 $file_type = DifferentialChangeType::FILE_SYMLINK;
             }
         }
         // TODO: We can detect binary changes as git does, through a combination
         // of running 'git check-attr' for stuff like 'binary', 'merge' or 'diff',
         // and by falling back to inspecting the first 8,000 characters of the
         // buffer for null bytes (this is seriously git's algorithm, see
         // buffer_is_binary() in xdiff-interface.c).
         $change_type = null;
         $change_path = $src_path;
         $change_target = null;
         $is_direct = true;
         switch ($action[0]) {
             case 'A':
                 $change_type = DifferentialChangeType::TYPE_ADD;
                 break;
             case 'D':
                 $change_type = DifferentialChangeType::TYPE_DELETE;
                 break;
             case 'C':
                 $change_type = DifferentialChangeType::TYPE_COPY_HERE;
                 $change_path = $dst_path;
                 $change_target = $src_path;
                 $copy_away[$change_target][] = $change_path;
                 break;
             case 'R':
                 $change_type = DifferentialChangeType::TYPE_MOVE_HERE;
                 $change_path = $dst_path;
                 $change_target = $src_path;
                 $move_away[$change_target][] = $change_path;
                 break;
             case 'T':
                 // Type of the file changed, fall through and treat it as a
                 // modification. Not 100% sure this is the right thing to do but it
                 // seems reasonable.
             // Type of the file changed, fall through and treat it as a
             // modification. Not 100% sure this is the right thing to do but it
             // seems reasonable.
             case 'M':
                 if ($file_type == DifferentialChangeType::FILE_DIRECTORY) {
                     $change_type = DifferentialChangeType::TYPE_CHILD;
                     $is_direct = false;
                 } else {
                     $change_type = DifferentialChangeType::TYPE_CHANGE;
                 }
                 break;
                 // NOTE: "U" (unmerged) and "X" (unknown) statuses are also possible
                 // in theory but shouldn't appear here.
             // NOTE: "U" (unmerged) and "X" (unknown) statuses are also possible
             // in theory but shouldn't appear here.
             default:
                 throw new Exception("Failed to parse line '{$line}'.");
         }
         $changes[$change_path] = array('repositoryID' => $repository->getID(), 'commitID' => $commit->getID(), 'path' => $change_path, 'changeType' => $change_type, 'fileType' => $file_type, 'isDirect' => $is_direct, 'commitSequence' => $commit->getEpoch(), 'targetPath' => $change_target, 'targetCommitID' => $change_target ? $commit->getID() : null);
     }
     // Add a change to '/' since git doesn't mention it.
     $changes['/'] = array('repositoryID' => $repository->getID(), 'commitID' => $commit->getID(), 'path' => '/', 'changeType' => DifferentialChangeType::TYPE_CHILD, 'fileType' => DifferentialChangeType::FILE_DIRECTORY, 'isDirect' => false, 'commitSequence' => $commit->getEpoch(), 'targetPath' => null, 'targetCommitID' => null);
     foreach ($copy_away as $change_path => $destinations) {
         if (isset($move_away[$change_path])) {
             $change_type = DifferentialChangeType::TYPE_MULTICOPY;
             $is_direct = true;
             unset($move_away[$change_path]);
         } else {
             $change_type = DifferentialChangeType::TYPE_COPY_AWAY;
             $is_direct = false;
         }
         $reference = $changes[reset($destinations)];
//.........这里部分代码省略.........