src/applications/diviner/renderer/DivinerDefaultRenderer.php

   1 <?php
   2
   3 final class DivinerDefaultRenderer extends DivinerRenderer {
   4
   5   public function renderAtom(DivinerAtom $atom) {
   6     $out = array(
   7       $this->renderAtomTitle($atom),
   8       $this->renderAtomProperties($atom),
   9       $this->renderAtomDescription($atom),
  10     );
  11
  12     return phutil_tag(
  13       'div',
  14       array(
  15         'class' => 'diviner-atom',
  16       ),
  17       $out);
  18   }
  19
  20   protected function renderAtomTitle(DivinerAtom $atom) {
  21     $name = $this->renderAtomName($atom);
  22     $type = $this->renderAtomType($atom);
  23
  24     return phutil_tag(
  25       'h1',
  26       array(
  27         'class' => 'atom-title',
  28       ),
  29       array($name, ' ', $type));
  30   }
  31
  32   protected function renderAtomName(DivinerAtom $atom) {
  33     return phutil_tag(
  34       'div',
  35       array(
  36         'class' => 'atom-name',
  37       ),
  38       $this->getAtomName($atom));
  39   }
  40
  41   protected function getAtomName(DivinerAtom $atom) {
  42     if ($atom->getDocblockMetaValue('title')) {
  43       return $atom->getDocblockMetaValue('title');
  44     }
  45
  46     return $atom->getName();
  47   }
  48
  49   protected function renderAtomType(DivinerAtom $atom) {
  50     return phutil_tag(
  51       'div',
  52       array(
  53         'class' => 'atom-name',
  54       ),
  55       $this->getAtomType($atom));
  56   }
  57
  58   protected function getAtomType(DivinerAtom $atom) {
  59     return ucwords($atom->getType());
  60   }
  61
  62   protected function renderAtomProperties(DivinerAtom $atom) {
  63     $props = $this->getAtomProperties($atom);
  64
  65     $out = array();
  66     foreach ($props as $prop) {
  67       list($key, $value) = $prop;
  68
  69       $out[] = phutil_tag('dt', array(), $key);
  70       $out[] = phutil_tag('dd', array(), $value);
  71     }
  72
  73     return phutil_tag(
  74       'dl',
  75       array(
  76         'class' => 'atom-properties',
  77       ),
  78       $out);
  79   }
  80
  81   protected function getAtomProperties(DivinerAtom $atom) {
  82     $properties = array();
  83     $properties[] = array(
  84       pht('Defined'),
  85       $atom->getFile().':'.$atom->getLine(),
  86     );
  87
  88     return $properties;
  89   }
  90
  91   protected function renderAtomDescription(DivinerAtom $atom) {
  92     $text = $this->getAtomDescription($atom);
  93     $engine = $this->getBlockMarkupEngine();
  94
  95     $this->pushAtomStack($atom);
  96       $description = $engine->markupText($text);
  97     $this->popAtomStack();
  98
  99     return phutil_tag(
 100       'div',
 101       array(
 102         'class' => 'atom-description',
 103       ),
 104       $description);
 105   }
 106
 107   protected function getAtomDescription(DivinerAtom $atom) {
 108     return $atom->getDocblockText();
 109   }
 110
 111   public function renderAtomSummary(DivinerAtom $atom) {
 112     $text = $this->getAtomSummary($atom);
 113     $engine = $this->getInlineMarkupEngine();
 114
 115     $this->pushAtomStack($atom);
 116       $summary = $engine->markupText($text);
 117     $this->popAtomStack();
 118
 119     return phutil_tag(
 120       'span',
 121       array(
 122         'class' => 'atom-summary',
 123       ),
 124       $summary);
 125   }
 126
 127   public function getAtomSummary(DivinerAtom $atom) {
 128     if ($atom->getDocblockMetaValue('summary')) {
 129       return $atom->getDocblockMetaValue('summary');
 130     }
 131
 132     $text = $this->getAtomDescription($atom);
 133     return PhabricatorMarkupEngine::summarize($text);
 134   }
 135
 136   public function renderAtomIndex(array $refs) {
 137     $refs = msort($refs, 'getSortKey');
 138
 139     $groups = mgroup($refs, 'getGroup');
 140
 141     $out = array();
 142     foreach ($groups as $group_key => $refs) {
 143       $out[] = phutil_tag(
 144         'h1',
 145         array(
 146           'class' => 'atom-group-name',
 147         ),
 148         $this->getGroupName($group_key));
 149
 150       $items = array();
 151       foreach ($refs as $ref) {
 152         $items[] = phutil_tag(
 153           'li',
 154           array(
 155             'class' => 'atom-index-item',
 156           ),
 157           array(
 158             $this->renderAtomRefLink($ref),
 159             ' - ',
 160             $ref->getSummary(),
 161           ));
 162       }
 163
 164       $out[] = phutil_tag(
 165         'ul',
 166         array(
 167           'class' => 'atom-index-list',
 168         ),
 169         $items);
 170     }
 171
 172     return phutil_tag(
 173       'div',
 174       array(
 175         'class' => 'atom-index',
 176       ),
 177       $out);
 178   }
 179
 180   protected function getGroupName($group_key) {
 181     return $group_key;
 182   }
 183
 184   protected function getBlockMarkupEngine() {
 185     $engine = PhabricatorMarkupEngine::newMarkupEngine(array());
 186
 187     $engine->setConfig('preserve-linebreaks', false);
 188     $engine->setConfig('viewer', new PhabricatorUser());
 189     $engine->setConfig('diviner.renderer', $this);
 190     $engine->setConfig('header.generate-toc', true);
 191
 192     return $engine;
 193   }
 194
 195   protected function getInlineMarkupEngine() {
 196     return $this->getBlockMarkupEngine();
 197   }
 198
 199   public function normalizeAtomRef(DivinerAtomRef $ref) {
 200     if (!strlen($ref->getBook())) {
 201       $ref->setBook($this->getConfig('name'));
 202     }
 203
 204     if ($ref->getBook() != $this->getConfig('name')) {
 205       // If the ref is from a different book, we can't normalize it.
 206       // Just return it as-is if it has enough information to resolve.
 207       if ($ref->getName() && $ref->getType()) {
 208         return $ref;
 209       } else {
 210         return null;
 211       }
 212     }
 213
 214     $atom = $this->getPublisher()->findAtomByRef($ref);
 215     if ($atom) {
 216       return $atom->getRef();
 217     }
 218
 219     return null;
 220   }
 221
 222   protected function getAtomHrefDepth(DivinerAtom $atom) {
 223     if ($atom->getContext()) {
 224       return 4;
 225     } else {
 226       return 3;
 227     }
 228   }
 229
 230   public function getHrefForAtomRef(DivinerAtomRef $ref) {
 231     $depth = 1;
 232
 233     $atom = $this->peekAtomStack();
 234     if ($atom) {
 235       $depth = $this->getAtomHrefDepth($atom);
 236     }
 237
 238     $href = str_repeat('../', $depth);
 239
 240     $book = $ref->getBook();
 241     $type = $ref->getType();
 242     $name = $ref->getName();
 243     $context = $ref->getContext();
 244
 245     $href .= $book.'/'.$type.'/';
 246     if ($context !== null) {
 247       $href .= $context.'/';
 248     }
 249     $href .= $name.'/index.html';
 250
 251     return $href;
 252   }
 253
 254   protected function renderAtomRefLink(DivinerAtomRef $ref) {
 255     return phutil_tag(
 256       'a',
 257       array(
 258         'href' => $this->getHrefForAtomRef($ref),
 259       ),
 260       $ref->getTitle());
 261   }
 262
 263 }