Implement basic one-up and test renderers
Summary:
This is a half-step toward one-up and test renderers. This is mostly a structural change, and has no user-facing impact. It splits the rendering hierarchy like this:
- Renderer (more methods are abstract than before)
- HTML Renderer (most HTML stuff has moved down from the base to here)
- HTML 1-up (placeholder only -- not yet a functional implementation)
- HTML 2-up (minimal changes, uses mostly old code)
- Test Renderer (unit-testable renderer base, implements text versions of the HTML stuff)
- Test 1-up (selects 1-up mode for test rendering)
- Test 2-up (selects 2-up mode for test rendering)
Broadly, I'm trying to share as much code as possible by splitting rendering into more, smaller stages. Specifically, we do this:
- Combine the various sorts of inputs (changes, context, inlines, etc.) into a single, relatively homogenous list of "primitives". This happens in the base class.
- The primitive types are: old (diff left side), new (diff right side), context ("show more context"), no-context ("context not available") and inline (inline comment).
- Possibly, apply a filtering/reordering step to the primitives to get them ready for 1-up rendering. This mostly removes information, and does a small amount of reordering. This also happens in the base class.
- Pass the primitives to the actual renderer, to convert them into HTML, text, or whatever else. This happens in the leaf class.
The primitive implementation is not yet complete (it doesn't attach as much information to the primitives as it should -- stuff like coverage and copies), but covers the basics.
The existing HTMLTwoUp renderer does not use the primitive path; instead, it still goes down the old path.
Test Plan: Ran unit tests, looked at a bunch of diffs.
Reviewers: btrahan
Reviewed By: btrahan
CC: aran
Maniphest Tasks: T2009
Differential Revision: https://secure.phabricator.com/D4421
2013-01-14 23:20:06 +01:00
|
|
|
<?php
|
|
|
|
|
|
|
|
final class DifferentialParseRenderTestCase extends PhabricatorTestCase {
|
|
|
|
|
|
|
|
public function testParseRender() {
|
|
|
|
$dir = dirname(__FILE__).'/data/';
|
|
|
|
foreach (Filesystem::listDirectory($dir, $show_hidden = false) as $file) {
|
|
|
|
if (!preg_match('/\.diff$/', $file)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
$data = Filesystem::readFile($dir.$file);
|
|
|
|
|
|
|
|
$opt_file = $dir.$file.'.options';
|
|
|
|
if (Filesystem::pathExists($opt_file)) {
|
|
|
|
$options = Filesystem::readFile($opt_file);
|
|
|
|
$options = json_decode($options, true);
|
|
|
|
if (!is_array($options)) {
|
|
|
|
throw new Exception("Invalid options file: {$opt_file}.");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
$options = array();
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach (array('one', 'two') as $type) {
|
|
|
|
$parser = $this->buildChangesetParser($type, $data, $file);
|
|
|
|
$actual = $parser->render(null, null, array());
|
|
|
|
|
|
|
|
$expect = Filesystem::readFile($dir.$file.'.'.$type.'.expect');
|
2013-02-17 15:37:02 +01:00
|
|
|
$this->assertEqual($expect, (string)$actual, $file.'.'.$type);
|
Implement basic one-up and test renderers
Summary:
This is a half-step toward one-up and test renderers. This is mostly a structural change, and has no user-facing impact. It splits the rendering hierarchy like this:
- Renderer (more methods are abstract than before)
- HTML Renderer (most HTML stuff has moved down from the base to here)
- HTML 1-up (placeholder only -- not yet a functional implementation)
- HTML 2-up (minimal changes, uses mostly old code)
- Test Renderer (unit-testable renderer base, implements text versions of the HTML stuff)
- Test 1-up (selects 1-up mode for test rendering)
- Test 2-up (selects 2-up mode for test rendering)
Broadly, I'm trying to share as much code as possible by splitting rendering into more, smaller stages. Specifically, we do this:
- Combine the various sorts of inputs (changes, context, inlines, etc.) into a single, relatively homogenous list of "primitives". This happens in the base class.
- The primitive types are: old (diff left side), new (diff right side), context ("show more context"), no-context ("context not available") and inline (inline comment).
- Possibly, apply a filtering/reordering step to the primitives to get them ready for 1-up rendering. This mostly removes information, and does a small amount of reordering. This also happens in the base class.
- Pass the primitives to the actual renderer, to convert them into HTML, text, or whatever else. This happens in the leaf class.
The primitive implementation is not yet complete (it doesn't attach as much information to the primitives as it should -- stuff like coverage and copies), but covers the basics.
The existing HTMLTwoUp renderer does not use the primitive path; instead, it still goes down the old path.
Test Plan: Ran unit tests, looked at a bunch of diffs.
Reviewers: btrahan
Reviewed By: btrahan
CC: aran
Maniphest Tasks: T2009
Differential Revision: https://secure.phabricator.com/D4421
2013-01-14 23:20:06 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private function buildChangesetParser($type, $data, $file) {
|
|
|
|
$parser = new ArcanistDiffParser();
|
|
|
|
$changes = $parser->parseDiff($data);
|
|
|
|
|
|
|
|
$diff = DifferentialDiff::newFromRawChanges($changes);
|
|
|
|
if (count($diff->getChangesets()) !== 1) {
|
|
|
|
throw new Exception("Expected one changeset: {$file}");
|
|
|
|
}
|
|
|
|
|
|
|
|
$changeset = head($diff->getChangesets());
|
|
|
|
|
|
|
|
$engine = new PhabricatorMarkupEngine();
|
2013-03-04 21:33:05 +01:00
|
|
|
$engine->setViewer(new PhabricatorUser());
|
Implement basic one-up and test renderers
Summary:
This is a half-step toward one-up and test renderers. This is mostly a structural change, and has no user-facing impact. It splits the rendering hierarchy like this:
- Renderer (more methods are abstract than before)
- HTML Renderer (most HTML stuff has moved down from the base to here)
- HTML 1-up (placeholder only -- not yet a functional implementation)
- HTML 2-up (minimal changes, uses mostly old code)
- Test Renderer (unit-testable renderer base, implements text versions of the HTML stuff)
- Test 1-up (selects 1-up mode for test rendering)
- Test 2-up (selects 2-up mode for test rendering)
Broadly, I'm trying to share as much code as possible by splitting rendering into more, smaller stages. Specifically, we do this:
- Combine the various sorts of inputs (changes, context, inlines, etc.) into a single, relatively homogenous list of "primitives". This happens in the base class.
- The primitive types are: old (diff left side), new (diff right side), context ("show more context"), no-context ("context not available") and inline (inline comment).
- Possibly, apply a filtering/reordering step to the primitives to get them ready for 1-up rendering. This mostly removes information, and does a small amount of reordering. This also happens in the base class.
- Pass the primitives to the actual renderer, to convert them into HTML, text, or whatever else. This happens in the leaf class.
The primitive implementation is not yet complete (it doesn't attach as much information to the primitives as it should -- stuff like coverage and copies), but covers the basics.
The existing HTMLTwoUp renderer does not use the primitive path; instead, it still goes down the old path.
Test Plan: Ran unit tests, looked at a bunch of diffs.
Reviewers: btrahan
Reviewed By: btrahan
CC: aran
Maniphest Tasks: T2009
Differential Revision: https://secure.phabricator.com/D4421
2013-01-14 23:20:06 +01:00
|
|
|
|
|
|
|
$cparser = new DifferentialChangesetParser();
|
|
|
|
$cparser->setDisableCache(true);
|
|
|
|
$cparser->setChangeset($changeset);
|
|
|
|
$cparser->setMarkupEngine($engine);
|
|
|
|
|
|
|
|
if ($type == 'one') {
|
|
|
|
$cparser->setRenderer(new DifferentialChangesetOneUpTestRenderer());
|
|
|
|
} else if ($type == 'two') {
|
|
|
|
$cparser->setRenderer(new DifferentialChangesetTwoUpTestRenderer());
|
|
|
|
} else {
|
|
|
|
throw new Exception("Unknown renderer type '{$type}'!");
|
|
|
|
}
|
|
|
|
|
|
|
|
return $cparser;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|