Modernize all Herald DifferentialDiff fields

Summary: Ref T8726. This deals with all the Differential diff fields, same deal as previous changes.

Test Plan:
- Wrote a rule with every field.
- Migrated it.
- Saw the same rule working.
- Rigged the hell out of transcripts (diffs normally do not generate transcripts, because the only action is "block" and they don't exist yet when Herald runs).
- Verified that all fields looked sensible in the transcript.

Reviewers: btrahan

Reviewed By: btrahan

Subscribers: epriestley

Maniphest Tasks: T8726

Differential Revision: https://secure.phabricator.com/D13590

resources/sql/autopatches/20150707.herald.1.sql

···
+UPDATE {$NAMESPACE}_herald.herald_condition c
+  JOIN {$NAMESPACE}_herald.herald_rule r
+  ON c.ruleID = r.id
+  SET c.fieldName = 'differential.diff.affected'
+  WHERE r.contentType = 'differential.diff'
+  AND c.fieldName = 'diff-file';
+
+UPDATE {$NAMESPACE}_herald.herald_condition c
+  JOIN {$NAMESPACE}_herald.herald_rule r
+  ON c.ruleID = r.id
+  SET c.fieldName = 'differential.diff.author'
+  WHERE r.contentType = 'differential.diff'
+  AND c.fieldName = 'author';
+
+UPDATE {$NAMESPACE}_herald.herald_condition c
+  JOIN {$NAMESPACE}_herald.herald_rule r
+  ON c.ruleID = r.id
+  SET c.fieldName = 'differential.diff.author.projects'
+  WHERE r.contentType = 'differential.diff'
+  AND c.fieldName = 'authorprojects';
+
+UPDATE {$NAMESPACE}_herald.herald_condition c
+  JOIN {$NAMESPACE}_herald.herald_rule r
+  ON c.ruleID = r.id
+  SET c.fieldName = 'differential.diff.new'
+  WHERE r.contentType = 'differential.diff'
+  AND c.fieldName = 'diff-added-content';
+
+UPDATE {$NAMESPACE}_herald.herald_condition c
+  JOIN {$NAMESPACE}_herald.herald_rule r
+  ON c.ruleID = r.id
+  SET c.fieldName = 'differential.diff.content'
+  WHERE r.contentType = 'differential.diff'
+  AND c.fieldName = 'diff-content';
+
+UPDATE {$NAMESPACE}_herald.herald_condition c
+  JOIN {$NAMESPACE}_herald.herald_rule r
+  ON c.ruleID = r.id
+  SET c.fieldName = 'differential.diff.old'
+  WHERE r.contentType = 'differential.diff'
+  AND c.fieldName = 'diff-removed-content';
+
+UPDATE {$NAMESPACE}_herald.herald_condition c
+  JOIN {$NAMESPACE}_herald.herald_rule r
+  ON c.ruleID = r.id
+  SET c.fieldName = 'differential.diff.repository'
+  WHERE r.contentType = 'differential.diff'
+  AND c.fieldName = 'repository';
+
+UPDATE {$NAMESPACE}_herald.herald_condition c
+  JOIN {$NAMESPACE}_herald.herald_rule r
+  ON c.ruleID = r.id
+  SET c.fieldName = 'differential.diff.repository.projects'
+  WHERE r.contentType = 'differential.diff'
+  AND c.fieldName = 'repository-projects';

src/__phutil_library_map__.php

···
     'DifferentialDependenciesField' => 'applications/differential/customfield/DifferentialDependenciesField.php',
     'DifferentialDependsOnField' => 'applications/differential/customfield/DifferentialDependsOnField.php',
     'DifferentialDiff' => 'applications/differential/storage/DifferentialDiff.php',
+    'DifferentialDiffAffectedFilesHeraldField' => 'applications/differential/herald/DifferentialDiffAffectedFilesHeraldField.php',
+    'DifferentialDiffAuthorHeraldField' => 'applications/differential/herald/DifferentialDiffAuthorHeraldField.php',
+    'DifferentialDiffAuthorProjectsHeraldField' => 'applications/differential/herald/DifferentialDiffAuthorProjectsHeraldField.php',
+    'DifferentialDiffContentAddedHeraldField' => 'applications/differential/herald/DifferentialDiffContentAddedHeraldField.php',
+    'DifferentialDiffContentHeraldField' => 'applications/differential/herald/DifferentialDiffContentHeraldField.php',
+    'DifferentialDiffContentRemovedHeraldField' => 'applications/differential/herald/DifferentialDiffContentRemovedHeraldField.php',
     'DifferentialDiffCreateController' => 'applications/differential/controller/DifferentialDiffCreateController.php',
     'DifferentialDiffEditor' => 'applications/differential/editor/DifferentialDiffEditor.php',
+    'DifferentialDiffHeraldField' => 'applications/differential/herald/DifferentialDiffHeraldField.php',
     'DifferentialDiffInlineCommentQuery' => 'applications/differential/query/DifferentialDiffInlineCommentQuery.php',
     'DifferentialDiffPHIDType' => 'applications/differential/phid/DifferentialDiffPHIDType.php',
     'DifferentialDiffProperty' => 'applications/differential/storage/DifferentialDiffProperty.php',
     'DifferentialDiffQuery' => 'applications/differential/query/DifferentialDiffQuery.php',
+    'DifferentialDiffRepositoryHeraldField' => 'applications/differential/herald/DifferentialDiffRepositoryHeraldField.php',
+    'DifferentialDiffRepositoryProjectsHeraldField' => 'applications/differential/herald/DifferentialDiffRepositoryProjectsHeraldField.php',
     'DifferentialDiffTableOfContentsView' => 'applications/differential/view/DifferentialDiffTableOfContentsView.php',
     'DifferentialDiffTestCase' => 'applications/differential/storage/__tests__/DifferentialDiffTestCase.php',
     'DifferentialDiffTransaction' => 'applications/differential/storage/DifferentialDiffTransaction.php',
···
     'HeraldController' => 'applications/herald/controller/HeraldController.php',
     'HeraldCustomAction' => 'applications/herald/extension/HeraldCustomAction.php',
     'HeraldDAO' => 'applications/herald/storage/HeraldDAO.php',
-    'HeraldDifferentialAdapter' => 'applications/herald/adapter/HeraldDifferentialAdapter.php',
-    'HeraldDifferentialDiffAdapter' => 'applications/herald/adapter/HeraldDifferentialDiffAdapter.php',
+    'HeraldDifferentialAdapter' => 'applications/differential/herald/HeraldDifferentialAdapter.php',
+    'HeraldDifferentialDiffAdapter' => 'applications/differential/herald/HeraldDifferentialDiffAdapter.php',
     'HeraldDifferentialRevisionAdapter' => 'applications/herald/adapter/HeraldDifferentialRevisionAdapter.php',
     'HeraldDisableController' => 'applications/herald/controller/HeraldDisableController.php',
     'HeraldEffect' => 'applications/herald/engine/HeraldEffect.php',
···
       'PhabricatorApplicationTransactionInterface',
       'PhabricatorDestructibleInterface',
     ),
+    'DifferentialDiffAffectedFilesHeraldField' => 'DifferentialDiffHeraldField',
+    'DifferentialDiffAuthorHeraldField' => 'DifferentialDiffHeraldField',
+    'DifferentialDiffAuthorProjectsHeraldField' => 'DifferentialDiffHeraldField',
+    'DifferentialDiffContentAddedHeraldField' => 'DifferentialDiffHeraldField',
+    'DifferentialDiffContentHeraldField' => 'DifferentialDiffHeraldField',
+    'DifferentialDiffContentRemovedHeraldField' => 'DifferentialDiffHeraldField',
     'DifferentialDiffCreateController' => 'DifferentialController',
     'DifferentialDiffEditor' => 'PhabricatorApplicationTransactionEditor',
+    'DifferentialDiffHeraldField' => 'HeraldField',
     'DifferentialDiffInlineCommentQuery' => 'PhabricatorDiffInlineCommentQuery',
     'DifferentialDiffPHIDType' => 'PhabricatorPHIDType',
     'DifferentialDiffProperty' => 'DifferentialDAO',
     'DifferentialDiffQuery' => 'PhabricatorCursorPagedPolicyAwareQuery',
+    'DifferentialDiffRepositoryHeraldField' => 'DifferentialDiffHeraldField',
+    'DifferentialDiffRepositoryProjectsHeraldField' => 'DifferentialDiffHeraldField',
     'DifferentialDiffTableOfContentsView' => 'AphrontView',
     'DifferentialDiffTestCase' => 'PhutilTestCase',
     'DifferentialDiffTransaction' => 'PhabricatorApplicationTransaction',

src/applications/differential/herald/DifferentialDiffAffectedFilesHeraldField.php

···
+<?php
+
+final class DifferentialDiffAffectedFilesHeraldField
+  extends DifferentialDiffHeraldField {
+
+  const FIELDCONST = 'differential.diff.affected';
+
+  public function getHeraldFieldName() {
+    return pht('Affected files');
+  }
+
+  public function getHeraldFieldValue($object) {
+    return $this->getAdapter()->loadAffectedPaths();
+  }
+
+  protected function getHeraldFieldStandardConditions() {
+    return self::STANDARD_TEXT_LIST;
+  }
+
+  public function getHeraldFieldValueType($condition) {
+    switch ($condition) {
+      case HeraldAdapter::CONDITION_EXISTS:
+      case HeraldAdapter::CONDITION_NOT_EXISTS:
+        return HeraldAdapter::VALUE_NONE;
+      default:
+        return HeraldAdapter::VALUE_TEXT;
+    }
+  }
+
+}

src/applications/differential/herald/DifferentialDiffAuthorHeraldField.php

···
+<?php
+
+final class DifferentialDiffAuthorHeraldField
+  extends DifferentialDiffHeraldField {
+
+  const FIELDCONST = 'differential.diff.author';
+
+  public function getHeraldFieldName() {
+    return pht('Author');
+  }
+
+  public function getHeraldFieldValue($object) {
+    return $object->getAuthorPHID();
+  }
+
+  protected function getHeraldFieldStandardConditions() {
+    return self::STANDARD_PHID;
+  }
+
+  public function getHeraldFieldValueType($condition) {
+    return HeraldAdapter::VALUE_USER;
+  }
+
+}

src/applications/differential/herald/DifferentialDiffAuthorProjectsHeraldField.php

···
+<?php
+
+final class DifferentialDiffAuthorProjectsHeraldField
+  extends DifferentialDiffHeraldField {
+
+  const FIELDCONST = 'differential.diff.author.projects';
+
+  public function getHeraldFieldName() {
+    return pht("Author's projects");
+  }
+
+  public function getHeraldFieldValue($object) {
+    return PhabricatorEdgeQuery::loadDestinationPHIDs(
+      $object->getAuthorPHID(),
+      PhabricatorProjectMemberOfProjectEdgeType::EDGECONST);
+  }
+
+  protected function getHeraldFieldStandardConditions() {
+    return self::STANDARD_LIST;
+  }
+
+  public function getHeraldFieldValueType($condition) {
+    switch ($condition) {
+      case HeraldAdapter::CONDITION_EXISTS:
+      case HeraldAdapter::CONDITION_NOT_EXISTS:
+        return HeraldAdapter::VALUE_NONE;
+      default:
+        return HeraldAdapter::VALUE_PROJECT;
+    }
+  }
+
+}

src/applications/differential/herald/DifferentialDiffContentAddedHeraldField.php

···
+<?php
+
+final class DifferentialDiffContentAddedHeraldField
+  extends DifferentialDiffHeraldField {
+
+  const FIELDCONST = 'differential.diff.new';
+
+  public function getHeraldFieldName() {
+    return pht('Added file content');
+  }
+
+  public function getHeraldFieldValue($object) {
+    return $this->getAdapter()->loadAddedContentDictionary();
+  }
+
+  protected function getHeraldFieldStandardConditions() {
+    return self::STANDARD_TEXT_MAP;
+  }
+
+  public function getHeraldFieldValueType($condition) {
+    return HeraldAdapter::VALUE_TEXT;
+  }
+
+}

src/applications/differential/herald/DifferentialDiffContentHeraldField.php

···
+<?php
+
+final class DifferentialDiffContentHeraldField
+  extends DifferentialDiffHeraldField {
+
+  const FIELDCONST = 'differential.diff.content';
+
+  public function getHeraldFieldName() {
+    return pht('Changed file content');
+  }
+
+  public function getHeraldFieldValue($object) {
+    return $this->getAdapter()->loadContentDictionary();
+  }
+
+  protected function getHeraldFieldStandardConditions() {
+    return self::STANDARD_TEXT_MAP;
+  }
+
+  public function getHeraldFieldValueType($condition) {
+    return HeraldAdapter::VALUE_TEXT;
+  }
+
+}

src/applications/differential/herald/DifferentialDiffContentRemovedHeraldField.php

···
+<?php
+
+final class DifferentialDiffContentRemovedHeraldField
+  extends DifferentialDiffHeraldField {
+
+  const FIELDCONST = 'differential.diff.old';
+
+  public function getHeraldFieldName() {
+    return pht('Removed file content');
+  }
+
+  public function getHeraldFieldValue($object) {
+    return $this->getAdapter()->loadRemovedContentDictionary();
+  }
+
+  protected function getHeraldFieldStandardConditions() {
+    return self::STANDARD_TEXT_MAP;
+  }
+
+  public function getHeraldFieldValueType($condition) {
+    return HeraldAdapter::VALUE_TEXT;
+  }
+
+}

src/applications/differential/herald/DifferentialDiffHeraldField.php

···
+<?php
+
+abstract class DifferentialDiffHeraldField extends HeraldField {
+
+  public function supportsObject($object) {
+    return ($object instanceof DifferentialDiff);
+  }
+
+}

src/applications/differential/herald/DifferentialDiffRepositoryHeraldField.php

···
+<?php
+
+final class DifferentialDiffRepositoryHeraldField
+  extends DifferentialDiffHeraldField {
+
+  const FIELDCONST = 'differential.diff.repository';
+
+  public function getHeraldFieldName() {
+    return pht('Repository');
+  }
+
+  public function getHeraldFieldValue($object) {
+    $repository = $this->getAdapter()->loadRepository();
+
+    if (!$repository) {
+      return null;
+    }
+
+    return $repository->getPHID();
+  }
+
+  protected function getHeraldFieldStandardConditions() {
+    return self::STANDARD_PHID_NULLABLE;
+  }
+
+  public function getHeraldFieldValueType($condition) {
+    switch ($condition) {
+      case HeraldAdapter::CONDITION_EXISTS:
+      case HeraldAdapter::CONDITION_NOT_EXISTS:
+        return HeraldAdapter::VALUE_NONE;
+      default:
+        return HeraldAdapter::VALUE_REPOSITORY;
+    }
+  }
+
+}

src/applications/differential/herald/DifferentialDiffRepositoryProjectsHeraldField.php

···
+<?php
+
+final class DifferentialDiffRepositoryProjectsHeraldField
+  extends DifferentialDiffHeraldField {
+
+  const FIELDCONST = 'differential.diff.repository.projects';
+
+  public function getHeraldFieldName() {
+    return pht('Repository projects');
+  }
+
+  public function getHeraldFieldValue($object) {
+    $repository = $this->getAdapter()->loadRepository();
+    if (!$repository) {
+      return array();
+    }
+
+    return PhabricatorEdgeQuery::loadDestinationPHIDs(
+      $repository->getPHID(),
+      PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);
+  }
+
+  protected function getHeraldFieldStandardConditions() {
+    return self::STANDARD_LIST;
+  }
+
+  public function getHeraldFieldValueType($condition) {
+    switch ($condition) {
+      case HeraldAdapter::CONDITION_EXISTS:
+      case HeraldAdapter::CONDITION_NOT_EXISTS:
+        return HeraldAdapter::VALUE_NONE;
+      default:
+        return HeraldAdapter::VALUE_PROJECT;
+    }
+  }
+
+}

src/applications/differential/herald/HeraldDifferentialDiffAdapter.php

···
+<?php
+
+final class HeraldDifferentialDiffAdapter extends HeraldDifferentialAdapter {
+
+  public function getAdapterApplicationClass() {
+    return 'PhabricatorDifferentialApplication';
+  }
+
+  protected function initializeNewAdapter() {
+    $this->setDiff(new DifferentialDiff());
+  }
+
+  public function isSingleEventAdapter() {
+    return true;
+  }
+
+  protected function loadChangesets() {
+    return $this->loadChangesetsWithHunks();
+  }
+
+  protected function loadChangesetsWithHunks() {
+    return $this->getDiff()->getChangesets();
+  }
+
+  public function getObject() {
+    return $this->getDiff();
+  }
+
+  public function getAdapterContentType() {
+    return 'differential.diff';
+  }
+
+  public function getAdapterContentName() {
+    return pht('Differential Diffs');
+  }
+
+  public function getAdapterContentDescription() {
+    return pht(
+      "React to new diffs being uploaded, before writes occur.\n".
+      "These rules can reject diffs before they are written to permanent ".
+      "storage, to prevent users from accidentally uploading private keys or ".
+      "other sensitive information.");
+  }
+
+  public function supportsRuleType($rule_type) {
+    switch ($rule_type) {
+      case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
+        return true;
+      case HeraldRuleTypeConfig::RULE_TYPE_OBJECT:
+      case HeraldRuleTypeConfig::RULE_TYPE_PERSONAL:
+      default:
+        return false;
+    }
+  }
+
+  public function getRepetitionOptions() {
+    return array(
+      HeraldRepetitionPolicyConfig::FIRST,
+    );
+  }
+
+  public function getHeraldName() {
+    return pht('New Diff');
+  }
+
+  public function getActionNameMap($rule_type) {
+    return array(
+      self::ACTION_BLOCK => pht('Block diff with message'),
+    ) + parent::getActionNameMap($rule_type);
+  }
+
+  public function getActions($rule_type) {
+    switch ($rule_type) {
+      case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
+        return array_merge(
+          array(
+            self::ACTION_BLOCK,
+            self::ACTION_NOTHING,
+          ),
+          parent::getActions($rule_type));
+    }
+  }
+
+  public function applyHeraldEffects(array $effects) {
+    assert_instances_of($effects, 'HeraldEffect');
+
+    $result = array();
+    foreach ($effects as $effect) {
+      $action = $effect->getAction();
+      switch ($action) {
+        case self::ACTION_BLOCK:
+          $result[] = new HeraldApplyTranscript(
+            $effect,
+            true,
+            pht('Blocked diff.'));
+          break;
+        default:
+          $result[] = $this->applyStandardEffect($effect);
+          break;
+      }
+    }
+
+    return $result;
+  }
+
+}

src/applications/herald/adapter/HeraldDifferentialAdapter.php src/applications/differential/herald/HeraldDifferentialAdapter.php

···
         $repository = id(new PhabricatorRepositoryQuery())
           ->setViewer(PhabricatorUser::getOmnipotentUser())
           ->withPHIDs(array($repository_phid))
-          ->needProjectPHIDs(true)
           ->executeOne();
       } else {
         $repository = null;
···
   }
 
 
-  protected function loadAffectedPaths() {
+  public function loadAffectedPaths() {
     $changesets = $this->loadChangesets();
 
     $paths = array();
···
     return $changeset->getAbsoluteRepositoryPath($repository, $diff);
   }
 
-  protected function loadContentDictionary() {
+  public function loadContentDictionary() {
     $add_lines = DifferentialHunk::FLAG_LINES_ADDED;
     $rem_lines = DifferentialHunk::FLAG_LINES_REMOVED;
     $mask = ($add_lines | $rem_lines);
     return $this->loadContentWithMask($mask);
   }
 
-  protected function loadAddedContentDictionary() {
+  public function loadAddedContentDictionary() {
     return $this->loadContentWithMask(DifferentialHunk::FLAG_LINES_ADDED);
   }
 
-  protected function loadRemovedContentDictionary() {
+  public function loadRemovedContentDictionary() {
     return $this->loadContentWithMask(DifferentialHunk::FLAG_LINES_REMOVED);
   }
 

src/applications/herald/adapter/HeraldDifferentialDiffAdapter.php

···
-<?php
-
-final class HeraldDifferentialDiffAdapter extends HeraldDifferentialAdapter {
-
-  public function getAdapterApplicationClass() {
-    return 'PhabricatorDifferentialApplication';
-  }
-
-  protected function initializeNewAdapter() {
-    $this->setDiff(new DifferentialDiff());
-  }
-
-  public function isSingleEventAdapter() {
-    return true;
-  }
-
-  protected function loadChangesets() {
-    return $this->loadChangesetsWithHunks();
-  }
-
-  protected function loadChangesetsWithHunks() {
-    return $this->getDiff()->getChangesets();
-  }
-
-  public function getObject() {
-    return $this->getDiff();
-  }
-
-  public function getAdapterContentType() {
-    return 'differential.diff';
-  }
-
-  public function getAdapterContentName() {
-    return pht('Differential Diffs');
-  }
-
-  public function getAdapterContentDescription() {
-    return pht(
-      "React to new diffs being uploaded, before writes occur.\n".
-      "These rules can reject diffs before they are written to permanent ".
-      "storage, to prevent users from accidentally uploading private keys or ".
-      "other sensitive information.");
-  }
-
-  public function supportsRuleType($rule_type) {
-    switch ($rule_type) {
-      case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
-        return true;
-      case HeraldRuleTypeConfig::RULE_TYPE_OBJECT:
-      case HeraldRuleTypeConfig::RULE_TYPE_PERSONAL:
-      default:
-        return false;
-    }
-  }
-
-  public function getFields() {
-    return array_merge(
-      array(
-        self::FIELD_AUTHOR,
-        self::FIELD_AUTHOR_PROJECTS,
-        self::FIELD_REPOSITORY,
-        self::FIELD_REPOSITORY_PROJECTS,
-        self::FIELD_DIFF_FILE,
-        self::FIELD_DIFF_CONTENT,
-        self::FIELD_DIFF_ADDED_CONTENT,
-        self::FIELD_DIFF_REMOVED_CONTENT,
-      ),
-      parent::getFields());
-  }
-
-  public function getRepetitionOptions() {
-    return array(
-      HeraldRepetitionPolicyConfig::FIRST,
-    );
-  }
-
-  public function getPHID() {
-    return $this->getObject()->getPHID();
-  }
-
-  public function getHeraldName() {
-    return pht('New Diff');
-  }
-
-  public function getActionNameMap($rule_type) {
-    return array(
-      self::ACTION_BLOCK => pht('Block diff with message'),
-    ) + parent::getActionNameMap($rule_type);
-  }
-
-  public function getHeraldField($field) {
-    switch ($field) {
-      case self::FIELD_AUTHOR:
-        return $this->getObject()->getAuthorPHID();
-        break;
-      case self::FIELD_AUTHOR_PROJECTS:
-        $author_phid = $this->getHeraldField(self::FIELD_AUTHOR);
-        if (!$author_phid) {
-          return array();
-        }
-
-        $projects = id(new PhabricatorProjectQuery())
-          ->setViewer(PhabricatorUser::getOmnipotentUser())
-          ->withMemberPHIDs(array($author_phid))
-          ->execute();
-
-        return mpull($projects, 'getPHID');
-      case self::FIELD_DIFF_FILE:
-        return $this->loadAffectedPaths();
-      case self::FIELD_REPOSITORY:
-        $repository = $this->loadRepository();
-        if (!$repository) {
-          return null;
-        }
-        return $repository->getPHID();
-      case self::FIELD_REPOSITORY_PROJECTS:
-        $repository = $this->loadRepository();
-        if (!$repository) {
-          return array();
-        }
-        return $repository->getProjectPHIDs();
-      case self::FIELD_DIFF_CONTENT:
-        return $this->loadContentDictionary();
-      case self::FIELD_DIFF_ADDED_CONTENT:
-        return $this->loadAddedContentDictionary();
-      case self::FIELD_DIFF_REMOVED_CONTENT:
-        return $this->loadRemovedContentDictionary();
-    }
-
-    return parent::getHeraldField($field);
-  }
-
-  public function getActions($rule_type) {
-    switch ($rule_type) {
-      case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
-        return array_merge(
-          array(
-            self::ACTION_BLOCK,
-            self::ACTION_NOTHING,
-          ),
-          parent::getActions($rule_type));
-    }
-  }
-
-  public function applyHeraldEffects(array $effects) {
-    assert_instances_of($effects, 'HeraldEffect');
-
-    $result = array();
-    foreach ($effects as $effect) {
-      $action = $effect->getAction();
-      switch ($action) {
-        case self::ACTION_BLOCK:
-          $result[] = new HeraldApplyTranscript(
-            $effect,
-            true,
-            pht('Blocked diff.'));
-          break;
-        default:
-          $result[] = $this->applyStandardEffect($effect);
-          break;
-      }
-    }
-
-    return $result;
-  }
-
-}