gerrit/polygerrit-ui/app/elements/diff/gr-diff-processor/gr-diff-processor_test.html

<!DOCTYPE html>
<!--
Copyright (C) 2016 The Android Open Source Project

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->

<meta name="viewport" content="width=device-width, minimum-scale=1.0, initial-scale=1.0, user-scalable=yes">
<title>gr-diff-processor test</title>

<script src="../../../bower_components/webcomponentsjs/webcomponents-lite.min.js"></script>
<script src="../../../bower_components/web-component-tester/browser.js"></script>
<link rel="import" href="../../../test/common-test-setup.html"/>
<link rel="import" href="gr-diff-processor.html">

<script>void(0);</script>

<test-fixture id="basic">
  <template>
    <gr-diff-processor></gr-diff-processor>
  </template>
</test-fixture>

<script>
  suite('gr-diff-processor tests', () => {
    const WHOLE_FILE = -1;
    const loremIpsum =
        'Lorem ipsum dolor sit amet, ei nonumes vituperata ius. ' +
        'Duo  animal omnesque fabellas et. Id has phaedrum dignissim ' +
        'deterruisset, pro ei petentium comprehensam, ut vis solum dicta. ' +
        'Eos cu aliquam labores qualisque, usu postea inermis te, et solum ' +
        'fugit assum per.';

    let element;
    let sandbox;

    setup(() => {
      sandbox = sinon.sandbox.create();
    });

    teardown(() => {
      sandbox.restore();
    });

    suite('not logged in', () => {
      setup(() => {
        element = fixture('basic');

        element.context = 4;
      });

      test('process loaded content', done => {
        const content = [
          {
            ab: [
              '<!DOCTYPE html>',
              '<meta charset="utf-8">',
            ],
          },
          {
            a: [
              '  Welcome ',
              '  to the wooorld of tomorrow!',
            ],
            b: [
              '  Hello, world!',
            ],
          },
          {
            ab: [
              'Leela: This is the only place the ship can’t hear us, so ',
              'everyone pretend to shower.',
              'Fry: Same as every day. Got it.',
            ],
          },
        ];

        element.process(content).then(() => {
          const groups = element.groups;

          assert.equal(groups.length, 4);

          let group = groups[0];
          assert.equal(group.type, GrDiffGroup.Type.BOTH);
          assert.equal(group.lines.length, 1);
          assert.equal(group.lines[0].text, '');
          assert.equal(group.lines[0].beforeNumber, GrDiffLine.FILE);
          assert.equal(group.lines[0].afterNumber, GrDiffLine.FILE);

          group = groups[1];
          assert.equal(group.type, GrDiffGroup.Type.BOTH);
          assert.equal(group.lines.length, 2);
          assert.equal(group.lines.length, 2);

          function beforeNumberFn(l) { return l.beforeNumber; }
          function afterNumberFn(l) { return l.afterNumber; }
          function textFn(l) { return l.text; }

          assert.deepEqual(group.lines.map(beforeNumberFn), [1, 2]);
          assert.deepEqual(group.lines.map(afterNumberFn), [1, 2]);
          assert.deepEqual(group.lines.map(textFn), [
            '<!DOCTYPE html>',
            '<meta charset="utf-8">',
          ]);

          group = groups[2];
          assert.equal(group.type, GrDiffGroup.Type.DELTA);
          assert.equal(group.lines.length, 3);
          assert.equal(group.adds.length, 1);
          assert.equal(group.removes.length, 2);
          assert.deepEqual(group.removes.map(beforeNumberFn), [3, 4]);
          assert.deepEqual(group.adds.map(afterNumberFn), [3]);
          assert.deepEqual(group.removes.map(textFn), [
            '  Welcome ',
            '  to the wooorld of tomorrow!',
          ]);
          assert.deepEqual(group.adds.map(textFn), [
            '  Hello, world!',
          ]);

          group = groups[3];
          assert.equal(group.type, GrDiffGroup.Type.BOTH);
          assert.equal(group.lines.length, 3);
          assert.deepEqual(group.lines.map(beforeNumberFn), [5, 6, 7]);
          assert.deepEqual(group.lines.map(afterNumberFn), [4, 5, 6]);
          assert.deepEqual(group.lines.map(textFn), [
            'Leela: This is the only place the ship can’t hear us, so ',
            'everyone pretend to shower.',
            'Fry: Same as every day. Got it.',
          ]);

          done();
        });
      });

      test('insert context groups', done => {
        const content = [
          {ab: []},
          {a: ['all work and no play make andybons a dull boy']},
          {ab: []},
          {b: ['elgoog elgoog elgoog']},
          {ab: []},
        ];
        for (let i = 0; i < 100; i++) {
          content[0].ab.push('all work and no play make jack a dull boy');
          content[4].ab.push('all work and no play make jill a dull girl');
        }
        for (let i = 0; i < 5; i++) {
          content[2].ab.push('no tv and no beer make homer go crazy');
        }

        const context = 10;
        element.context = context;

        element.process(content).then(() => {
          const groups = element.groups;

          assert.equal(groups[0].type, GrDiffGroup.Type.BOTH);
          assert.equal(groups[0].lines.length, 1);
          assert.equal(groups[0].lines[0].text, '');
          assert.equal(groups[0].lines[0].beforeNumber, GrDiffLine.FILE);
          assert.equal(groups[0].lines[0].afterNumber, GrDiffLine.FILE);

          assert.equal(groups[1].type, GrDiffGroup.Type.CONTEXT_CONTROL);
          assert.instanceOf(groups[1].lines[0].contextGroup, GrDiffGroup);
          assert.equal(groups[1].lines[0].contextGroup.lines.length, 90);
          for (const l of groups[1].lines[0].contextGroup.lines) {
            assert.equal(l.text, content[0].ab[0]);
          }

          assert.equal(groups[2].type, GrDiffGroup.Type.BOTH);
          assert.equal(groups[2].lines.length, context);
          for (const l of groups[2].lines) {
            assert.equal(l.text, content[0].ab[0]);
          }

          assert.equal(groups[3].type, GrDiffGroup.Type.DELTA);
          assert.equal(groups[3].lines.length, 1);
          assert.equal(groups[3].removes.length, 1);
          assert.equal(groups[3].removes[0].text,
              'all work and no play make andybons a dull boy');

          assert.equal(groups[4].type, GrDiffGroup.Type.BOTH);
          assert.equal(groups[4].lines.length, 5);
          for (const l of groups[4].lines) {
            assert.equal(l.text, content[2].ab[0]);
          }

          assert.equal(groups[5].type, GrDiffGroup.Type.DELTA);
          assert.equal(groups[5].lines.length, 1);
          assert.equal(groups[5].adds.length, 1);
          assert.equal(groups[5].adds[0].text, 'elgoog elgoog elgoog');

          assert.equal(groups[6].type, GrDiffGroup.Type.BOTH);
          assert.equal(groups[6].lines.length, context);
          for (const l of groups[6].lines) {
            assert.equal(l.text, content[4].ab[0]);
          }

          assert.equal(groups[7].type, GrDiffGroup.Type.CONTEXT_CONTROL);
          assert.instanceOf(groups[7].lines[0].contextGroup, GrDiffGroup);
          assert.equal(groups[7].lines[0].contextGroup.lines.length, 90);
          for (const l of groups[7].lines[0].contextGroup.lines) {
            assert.equal(l.text, content[4].ab[0]);
          }

          done();
        });
      });

      test('insert context groups', done => {
        const content = [
          {a: ['all work and no play make andybons a dull boy']},
          {ab: []},
          {b: ['elgoog elgoog elgoog']},
        ];
        for (let i = 0; i < 50; i++) {
          content[1].ab.push('no tv and no beer make homer go crazy');
        }

        const context = 10;
        element.context = context;

        element.process(content).then(() => {
          const groups = element.groups;

          assert.equal(groups[0].type, GrDiffGroup.Type.BOTH);
          assert.equal(groups[0].lines.length, 1);
          assert.equal(groups[0].lines[0].text, '');
          assert.equal(groups[0].lines[0].beforeNumber, GrDiffLine.FILE);
          assert.equal(groups[0].lines[0].afterNumber, GrDiffLine.FILE);

          assert.equal(groups[1].type, GrDiffGroup.Type.DELTA);
          assert.equal(groups[1].lines.length, 1);
          assert.equal(groups[1].removes.length, 1);
          assert.equal(groups[1].removes[0].text,
              'all work and no play make andybons a dull boy');

          assert.equal(groups[2].type, GrDiffGroup.Type.BOTH);
          assert.equal(groups[2].lines.length, context);
          for (const l of groups[2].lines) {
            assert.equal(l.text, content[1].ab[0]);
          }

          assert.equal(groups[3].type, GrDiffGroup.Type.CONTEXT_CONTROL);
          assert.instanceOf(groups[3].lines[0].contextGroup, GrDiffGroup);
          assert.equal(groups[3].lines[0].contextGroup.lines.length, 30);
          for (const l of groups[3].lines[0].contextGroup.lines) {
            assert.equal(l.text, content[1].ab[0]);
          }

          assert.equal(groups[4].type, GrDiffGroup.Type.BOTH);
          assert.equal(groups[4].lines.length, context);
          for (const l of groups[4].lines) {
            assert.equal(l.text, content[1].ab[0]);
          }

          assert.equal(groups[5].type, GrDiffGroup.Type.DELTA);
          assert.equal(groups[5].lines.length, 1);
          assert.equal(groups[5].adds.length, 1);
          assert.equal(groups[5].adds[0].text, 'elgoog elgoog elgoog');

          done();
        });
      });

      test('break up common diff chunks', () => {
        element.keyLocations = {
          left: {1: true},
          right: {10: true},
        };
        const lineNums = {left: 0, right: 0};

        const content = [
          {
            ab: [
              'Copyright (C) 2015 The Android Open Source Project',
              '',
              'Licensed under the Apache License, Version 2.0 (the "License");',
              'you may not use this file except in compliance with the ' +
                  'License.',
              'You may obtain a copy of the License at',
              '',
              'http://www.apache.org/licenses/LICENSE-2.0',
              '',
              'Unless required by applicable law or agreed to in writing, ',
              'software distributed under the License is distributed on an ',
              '"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, ',
              'either express or implied. See the License for the specific ',
              'language governing permissions and limitations under the ' +
                  'License.',
            ],
          },
        ];
        const result =
            element._splitCommonGroupsWithComments(content, lineNums);
        assert.deepEqual(result, [
          {
            ab: ['Copyright (C) 2015 The Android Open Source Project'],
          },
          {
            ab: [
              '',
              'Licensed under the Apache License, Version 2.0 (the "License");',
              'you may not use this file except in compliance with the ' +
                  'License.',
              'You may obtain a copy of the License at',
              '',
              'http://www.apache.org/licenses/LICENSE-2.0',
              '',
              'Unless required by applicable law or agreed to in writing, ',
            ],
          },
          {
            ab: [
              'software distributed under the License is distributed on an '],
          },
          {
            ab: [
              '"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, ',
              'either express or implied. See the License for the specific ',
              'language governing permissions and limitations under the ' +
                  'License.',
            ],
          },
        ]);
      });

      test('breaks-down shared chunks w/ whole-file', () => {
        const size = 120 * 2 + 5;
        const lineNums = {left: 0, right: 0};
        const content = [{
          ab: _.times(size, () => { return `${Math.random()}`; }),
        }];
        element.context = -1;
        const result =
            element._splitCommonGroupsWithComments(content, lineNums);
        assert.equal(result.length, 2);
        assert.deepEqual(result[0].ab, content[0].ab.slice(0, 120));
        assert.deepEqual(result[1].ab, content[0].ab.slice(120));
      });

      test('does not break-down shared chunks w/ context', () => {
        const lineNums = {left: 0, right: 0};
        const content = [{
          ab: _.times(75, () => { return `${Math.random()}`; }),
        }];
        element.context = 4;
        const result =
            element._splitCommonGroupsWithComments(content, lineNums);
        assert.deepEqual(result, content);
      });

      test('intraline normalization', () => {
        // The content and highlights are in the format returned by the Gerrit
        // REST API.
        let content = [
          '      <section class="summary">',
          '        <gr-linked-text content="' +
              '[[_computeCurrentRevisionMessage(change)]]"></gr-linked-text>',
          '      </section>',
        ];
        let highlights = [
          [31, 34], [42, 26],
        ];

        let results = element._normalizeIntralineHighlights(content,
            highlights);
        assert.deepEqual(results, [
          {
            contentIndex: 0,
            startIndex: 31,
          },
          {
            contentIndex: 1,
            startIndex: 0,
            endIndex: 33,
          },
          {
            contentIndex: 1,
            startIndex: 75,
          },
          {
            contentIndex: 2,
            startIndex: 0,
            endIndex: 6,
          },
        ]);

        content = [
          '        this._path = value.path;',
          '',
          '        // When navigating away from the page, there is a ' +
            'possibility that the',
          '        // patch number is no longer a part of the URL ' +
            '(say when navigating to',
          '        // the top-level change info view) and therefore ' +
            'undefined in `params`.',
          '        if (!this._patchRange.patchNum) {',
        ];
        highlights = [
          [14, 17],
          [11, 70],
          [12, 67],
          [12, 67],
          [14, 29],
        ];
        results = element._normalizeIntralineHighlights(content, highlights);
        assert.deepEqual(results, [
          {
            contentIndex: 0,
            startIndex: 14,
            endIndex: 31,
          },
          {
            contentIndex: 2,
            startIndex: 8,
            endIndex: 78,
          },
          {
            contentIndex: 3,
            startIndex: 11,
            endIndex: 78,
          },
          {
            contentIndex: 4,
            startIndex: 11,
            endIndex: 78,
          },
          {
            contentIndex: 5,
            startIndex: 12,
            endIndex: 41,
          },
        ]);
      });

      test('scrolling pauses rendering', () => {
        const contentRow = {
          ab: [
            '<!DOCTYPE html>',
            '<meta charset="utf-8">',
          ],
        };
        const content = _.times(200, _.constant(contentRow));
        sandbox.stub(element, 'async');
        element._isScrolling = true;
        element.process(content);
        assert.equal(element.groups.length, 1);
        element._isScrolling = false;
        element.process(content);
        assert.equal(element.groups.length, 33);
      });

      test('image diffs', () => {
        const contentRow = {
          ab: [
            '<!DOCTYPE html>',
            '<meta charset="utf-8">',
          ],
        };
        const content = _.times(200, _.constant(contentRow));
        sandbox.stub(element, 'async');
        element.process(content, true);
        assert.equal(element.groups.length, 1);

        // Image diffs don't process content, just the 'FILE' line.
        assert.equal(element.groups[0].lines.length, 1);
      });


      suite('gr-diff-processor helpers', () => {
        let rows;

        setup(() => {
          rows = loremIpsum.split(' ');
        });

        test('_sharedGroupsFromRows WHOLE_FILE', () => {
          const context = WHOLE_FILE;
          const lineNumbers = {left: 10, right: 100};
          const result = element._sharedGroupsFromRows(
              rows, context, lineNumbers.left, lineNumbers.right, null);

          // Results in one, uncollapsed group with all rows.
          assert.equal(result.length, 1);
          assert.equal(result[0].type, GrDiffGroup.Type.BOTH);
          assert.equal(result[0].lines.length, rows.length);

          // Line numbers are set correctly.
          assert.equal(result[0].lines[0].beforeNumber, lineNumbers.left + 1);
          assert.equal(result[0].lines[0].afterNumber, lineNumbers.right + 1);

          assert.equal(result[0].lines[rows.length - 1].beforeNumber,
              lineNumbers.left + rows.length);
          assert.equal(result[0].lines[rows.length - 1].afterNumber,
              lineNumbers.right + rows.length);
        });

        test('_sharedGroupsFromRows context', () => {
          const context = 10;
          const result = element._sharedGroupsFromRows(
              rows, context, 10, 100, null);
          const expectedCollapseSize = rows.length - 2 * context;

          assert.equal(result.length, 3, 'Results in three groups');

          // The first and last are uncollapsed context, whereas the middle has
          // a single context-control line.
          assert.equal(result[0].lines.length, context);
          assert.equal(result[1].lines.length, 1);
          assert.equal(result[2].lines.length, context);

          // The collapsed group has the hidden lines as its context group.
          assert.equal(result[1].lines[0].contextGroup.lines.length,
              expectedCollapseSize);
        });

        test('_sharedGroupsFromRows first', () => {
          const context = 10;
          const result = element._sharedGroupsFromRows(
              rows, context, 10, 100, 'first');
          const expectedCollapseSize = rows.length - context;

          assert.equal(result.length, 2, 'Results in two groups');

          // Only the first group is collapsed.
          assert.equal(result[0].lines.length, 1);
          assert.equal(result[1].lines.length, context);

          // The collapsed group has the hidden lines as its context group.
          assert.equal(result[0].lines[0].contextGroup.lines.length,
              expectedCollapseSize);
        });

        test('_sharedGroupsFromRows few-rows', () => {
          // Only ten rows.
          rows = rows.slice(0, 10);
          const context = 10;
          const result = element._sharedGroupsFromRows(
              rows, context, 10, 100, 'first');

          // Results in one uncollapsed group with all rows.
          assert.equal(result.length, 1, 'Results in one group');
          assert.equal(result[0].lines.length, rows.length);
        });

        test('_sharedGroupsFromRows no single line collapse', () => {
          rows = rows.slice(0, 7);
          const context = 3;
          const result = element._sharedGroupsFromRows(
              rows, context, 10, 100);

          // Results in one uncollapsed group with all rows.
          assert.equal(result.length, 1, 'Results in one group');
          assert.equal(result[0].lines.length, rows.length);
        });

        test('_deltaLinesFromRows', () => {
          const startLineNum = 10;
          let result = element._deltaLinesFromRows(GrDiffLine.Type.ADD, rows,
              startLineNum);

          assert.equal(result.length, rows.length);
          assert.equal(result[0].type, GrDiffLine.Type.ADD);
          assert.equal(result[0].afterNumber, startLineNum + 1);
          assert.notOk(result[0].beforeNumber);
          assert.equal(result[result.length - 1].afterNumber,
              startLineNum + rows.length);
          assert.notOk(result[result.length - 1].beforeNumber);

          result = element._deltaLinesFromRows(GrDiffLine.Type.REMOVE, rows,
              startLineNum);

          assert.equal(result.length, rows.length);
          assert.equal(result[0].type, GrDiffLine.Type.REMOVE);
          assert.equal(result[0].beforeNumber, startLineNum + 1);
          assert.notOk(result[0].afterNumber);
          assert.equal(result[result.length - 1].beforeNumber,
              startLineNum + rows.length);
          assert.notOk(result[result.length - 1].afterNumber);
        });
      });

      suite('_breakdown*', () => {
        test('_breakdownGroup breaks down additions', () => {
          sandbox.spy(element, '_breakdown');
          const chunk = {b: ['blah', 'blah', 'blah']};
          const result = element._breakdownGroup(chunk);
          assert.deepEqual(result, [chunk]);
          assert.isTrue(element._breakdown.called);
        });

        test('_breakdown common case', () => {
          const array = 'Lorem ipsum dolor sit amet, suspendisse inceptos'
              .split(' ');
          const size = 3;

          const result = element._breakdown(array, size);

          for (const subResult of result) {
            assert.isAtMost(subResult.length, size);
          }
          const flattened = result
              .reduce((a, b) => { return a.concat(b); }, []);
          assert.deepEqual(flattened, array);
        });

        test('_breakdown smaller than size', () => {
          const array = 'Lorem ipsum dolor sit amet, suspendisse inceptos'
              .split(' ');
          const size = 10;
          const expected = [array];

          const result = element._breakdown(array, size);

          assert.deepEqual(result, expected);
        });

        test('_breakdown empty', () => {
          const array = [];
          const size = 10;
          const expected = [];

          const result = element._breakdown(array, size);

          assert.deepEqual(result, expected);
        });
      });
    });

    test('detaching cancels', () => {
      element = fixture('basic');
      sandbox.stub(element, 'cancel');
      element.detached();
      assert(element.cancel.called);
    });
  });
</script>
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								<!DOCTYPE html>
 								<!--
 								Copyright (C) 2016 The Android Open Source Project
 								Licensed under the Apache License, Version 2.0 (the "License");
 								you may not use this file except in compliance with the License.
 								You may obtain a copy of the License at
 								http://www.apache.org/licenses/LICENSE-2.0
 								Unless required by applicable law or agreed to in writing, software
 								distributed under the License is distributed on an "AS IS" BASIS,
 								WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 								See the License for the specific language governing permissions and
 								limitations under the License.
 								-->
 								<meta name="viewport" content="width=device-width, minimum-scale=1.0, initial-scale=1.0, user-scalable=yes">
 								<title>gr-diff-processor test</title>
-												Collection of prospective test flake fixes

Potentially related:
https://github.com/Polymer/web-component-tester/issues/505

Bug: Issue 5792
Change-Id: I9ab6e8e40d9811dd52906335426764c052907609

											
										
										
											2017-03-28 17:02:44 -07:00
+								<script src="../../../bower_components/webcomponentsjs/webcomponents-lite.min.js"></script>
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								<script src="../../../bower_components/web-component-tester/browser.js"></script>
-												Polygerrit now loads polymer-resin

polymer-resin intercepts polymer property assignments
before they reach XSS-vulnerable sinks like `href="..."`
and text nodes in `<script>` elements.

This follows the instructions in WORKSPACE for adding a new bower
dependency with kaspern's tweak to use the dependency in a rule so
that it's found.  //lib/js/bower_components.bzl has already been
rolled-back per those instructions.

The license is the polymer license as can be seen at
https://github.com/Polymer/polymer-resin/blob/master/LICENSE though
I'm not sure that //tools/js/bower2bazel.py recognizes it as such.

Docs for the added component are available at
https://github.com/Polymer/polymer-resin/blob/master/README.md
https://github.com/Polymer/polymer-resin/blob/master/getting-started.md

With this change, when I introduce an XSS vulnerability as below,
polymer-resin intercepts and stops it.

Patch that introduces a strawman vulnerability.

--- a/polygerrit-ui/app/elements/core/gr-main-header/gr-main-header.js
+++ b/polygerrit-ui/app/elements/core/gr-main-header/gr-main-header.js
@@ -55,6 +55,10 @@
         url: '/q/status:abandoned',
         name: 'Abandoned',
       },
+      {
+        url: location.hash.replace(/^#/, '') || 'http://example.com/#fragment_echoed_here',
+        name: 'XSS Me',
+      },
     ],
   }];

---

Address kaspern's and paladox's comments.

---

Undo version bumps for bower dependencies.

---

Change Soy index template to parallel app/index.html.

---

update polymer-resin to version 1.1.1-beta

----

Load polymer-resin into polygerrit-ui/**/*_test.html

After this, I ran the tests with
  -l chrome
  -l firefox

I ran a handful of tests with -p and observed that the
console shows "initResin" is called before test cases start
executing.

These changes were done programmaticly by running the script below
(approximately) thus:
```
gerrit/ $ cd polygerrit-ui/app
app/ $ find . -name \*test.html | xargs perl hack-tests.pl
```

```
use strict;

sub removeResin($) {
  my $s = $_[0];
  $s =~ s@<link rel="import" href="[^"]*/polymer-resin/[^"]*"[^>]*>\n?@@;
  $s =~ s@<script src="[^"]*/polymer-resin/[^"]*"></script>\n?@@;
  $s =~ s@<script>\s*security\.polymer_resin.*?</script>\n?@@s;
  return $s;
}

for my $f (@ARGV) {
  next if $f =~ m@/bower_components/|/node_modules/@;

  system('git', 'checkout', $f);
  print "$f\n";

  my @lines = ();
  open(IN, "<$f") or die "$f: $!";
  my $maxLineOfMatch = 0;
  while (<IN>) {
    push(@lines, $_);
    # Put a marker after core loading directives.
    $maxLineOfMatch = scalar(@lines)
      if m@/webcomponentsjs/|/polymer[.]html\b|/browser[.]js@;
  }
  close(IN) or die "$f: $!";

  die "$f missing loading directives" unless $maxLineOfMatch;

  # Given ./a/b/c/my_test.html, $pathToRoot is "../../.."
  # assuming no non-leading . or .. components in the path from find.
  my $pathToRoot = $f;
  $pathToRoot =~ s@^\.\/@@;
  $pathToRoot =~ s@^(.*?/)?app/@@;
  $pathToRoot =~ s@\/[^\/]*$@@;
  $pathToRoot =~ s@[^/]+@..@g;

  my $nLines = scalar(@lines);
  open(OUT, ">$f") or die "$f: $!";

  # Output the lines up to the last polymer-resin dependency
  # loaded explicitly by this test.
  my $before = join '', @lines[0..($maxLineOfMatch - 1)];
  $before = removeResin($before);
  print OUT "$before";

  # Dump out the lines that load polymer-resin and configure it for
  # polygerrit.
  if (1) {
      print OUT qq'<link rel="import" href="$pathToRoot/bower_components/polymer-resin/standalone/polymer-resin-debug.html"/>
<script>
security.polymer_resin.install({allowedIdentifierPrefixes: [\'\']});
</script>
    ';
  }

  # Emit any remaining lines.
  my $after = join '', @lines[$maxLineOfMatch..$#lines];
  $after = removeResin($after);
  $after =~ s/^\n*//;
  print OUT "$after";

  close(OUT) or die "$f: $!";
}
```

---

update polymer-resin to version 1.2.1-beta

---

update Soy index template to new style polymer-resin initialization

----

fix lint warnings

----

Load test/common-test-setup.html into *_test.html

Instead of inserting instructions to load and initialize polymer-resin into
every test file, add a common-test-setup.html that does that and also fold
iron-test-helpers loading into it.

----

imported files do not need to load webcomponentsjs

Change-Id: I71221c36ed8a0fe7f8720c1064a2fcc9555bb8df

											
										
										
											2017-05-08 14:07:13 -04:00
+								<link rel="import" href="../../../test/common-test-setup.html"/>
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								<link rel="import" href="gr-diff-processor.html">
-												Collection of prospective test flake fixes

Potentially related:
https://github.com/Polymer/web-component-tester/issues/505

Bug: Issue 5792
Change-Id: I9ab6e8e40d9811dd52906335426764c052907609

											
										
										
											2017-03-28 17:02:44 -07:00
+								<script>void(0);</script>
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								<test-fixture id="basic">
 								  <template>
 								    <gr-diff-processor></gr-diff-processor>
 								  </template>
 								</test-fixture>
 								<script>
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								  suite('gr-diff-processor tests', () => {
 								    const WHOLE_FILE = -1;
 								    const loremIpsum =
 								        'Lorem ipsum dolor sit amet, ei nonumes vituperata ius. ' +
-												Refactor gr-diff-processor to use an asynchronous loop

Modifies the `process` method of gr-diff-processor to traverse diff
content using an asynchronous recursive loop rather than a blocking
for-loop. The async version maintains the promise interface already
established.

Refactored to constrain side-effects to the `process` method. Whereas,
formerly, helper methods in gr-diff-processor both read and wrote the
component's internal state, they are rewritten to be more pure, making
them simpler to understand, test, and invoke asynchronously.

Documentation is added throughout as well as tests for helper functions.

Note that this change only makes the processing step asynchronous.
Upgrading the diff-rendering stage to be non-blocking will come in a
later change.

Change-Id: Ifd50eeb75797b173937890caacc92cad5675fc20

											
										
										
											2016-06-28 10:33:33 -07:00
+								        'Duo  animal omnesque fabellas et. Id has phaedrum dignissim ' +
 								        'deterruisset, pro ei petentium comprehensam, ut vis solum dicta. ' +
 								        'Eos cu aliquam labores qualisque, usu postea inermis te, et solum ' +
 								        'fugit assum per.';
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								    let element;
 								    let sandbox;
-												Pause diff rendering on window scroll

Bug: Issue 4364
Change-Id: If1bc1560fa98b170e776fd0afd9782d8ca38e769

											
										
										
											2016-08-22 16:56:23 -07:00
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								    setup(() => {
-												Pause diff rendering on window scroll

Bug: Issue 4364
Change-Id: If1bc1560fa98b170e776fd0afd9782d8ca38e769

											
										
										
											2016-08-22 16:56:23 -07:00
+								      sandbox = sinon.sandbox.create();
 								    });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								    teardown(() => {
-												Pause diff rendering on window scroll

Bug: Issue 4364
Change-Id: If1bc1560fa98b170e776fd0afd9782d8ca38e769

											
										
										
											2016-08-22 16:56:23 -07:00
+								      sandbox.restore();
 								    });
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								    suite('not logged in', () => {
 								      setup(() => {
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								        element = fixture('basic');
 								        element.context = 4;
 								      });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								      test('process loaded content', done => {
 								        const content = [
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								          {
 								            ab: [
 								              '<!DOCTYPE html>',
 								              '<meta charset="utf-8">',
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								            ],
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								          },
 								          {
 								            a: [
 								              '  Welcome ',
 								              '  to the wooorld of tomorrow!',
 								            ],
 								            b: [
 								              '  Hello, world!',
 								            ],
 								          },
 								          {
 								            ab: [
 								              'Leela: This is the only place the ship can’t hear us, so ',
 								              'everyone pretend to shower.',
 								              'Fry: Same as every day. Got it.',
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								            ],
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								          },
 								        ];
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        element.process(content).then(() => {
 								          const groups = element.groups;
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
 								          assert.equal(groups.length, 4);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          let group = groups[0];
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								          assert.equal(group.type, GrDiffGroup.Type.BOTH);
 								          assert.equal(group.lines.length, 1);
 								          assert.equal(group.lines[0].text, '');
 								          assert.equal(group.lines[0].beforeNumber, GrDiffLine.FILE);
 								          assert.equal(group.lines[0].afterNumber, GrDiffLine.FILE);
 								          group = groups[1];
 								          assert.equal(group.type, GrDiffGroup.Type.BOTH);
 								          assert.equal(group.lines.length, 2);
 								          assert.equal(group.lines.length, 2);
 								          function beforeNumberFn(l) { return l.beforeNumber; }
 								          function afterNumberFn(l) { return l.afterNumber; }
 								          function textFn(l) { return l.text; }
 								          assert.deepEqual(group.lines.map(beforeNumberFn), [1, 2]);
 								          assert.deepEqual(group.lines.map(afterNumberFn), [1, 2]);
 								          assert.deepEqual(group.lines.map(textFn), [
 								            '<!DOCTYPE html>',
 								            '<meta charset="utf-8">',
 								          ]);
 								          group = groups[2];
 								          assert.equal(group.type, GrDiffGroup.Type.DELTA);
 								          assert.equal(group.lines.length, 3);
 								          assert.equal(group.adds.length, 1);
 								          assert.equal(group.removes.length, 2);
 								          assert.deepEqual(group.removes.map(beforeNumberFn), [3, 4]);
 								          assert.deepEqual(group.adds.map(afterNumberFn), [3]);
 								          assert.deepEqual(group.removes.map(textFn), [
 								            '  Welcome ',
 								            '  to the wooorld of tomorrow!',
 								          ]);
 								          assert.deepEqual(group.adds.map(textFn), [
 								            '  Hello, world!',
 								          ]);
 								          group = groups[3];
 								          assert.equal(group.type, GrDiffGroup.Type.BOTH);
 								          assert.equal(group.lines.length, 3);
 								          assert.deepEqual(group.lines.map(beforeNumberFn), [5, 6, 7]);
 								          assert.deepEqual(group.lines.map(afterNumberFn), [4, 5, 6]);
 								          assert.deepEqual(group.lines.map(textFn), [
 								            'Leela: This is the only place the ship can’t hear us, so ',
 								            'everyone pretend to shower.',
 								            'Fry: Same as every day. Got it.',
 								          ]);
 								          done();
 								        });
 								      });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								      test('insert context groups', done => {
 								        const content = [
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								          {ab: []},
 								          {a: ['all work and no play make andybons a dull boy']},
 								          {ab: []},
 								          {b: ['elgoog elgoog elgoog']},
 								          {ab: []},
 								        ];
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        for (let i = 0; i < 100; i++) {
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								          content[0].ab.push('all work and no play make jack a dull boy');
 								          content[4].ab.push('all work and no play make jill a dull girl');
 								        }
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        for (let i = 0; i < 5; i++) {
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								          content[2].ab.push('no tv and no beer make homer go crazy');
 								        }
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        const context = 10;
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								        element.context = context;
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        element.process(content).then(() => {
 								          const groups = element.groups;
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
 								          assert.equal(groups[0].type, GrDiffGroup.Type.BOTH);
 								          assert.equal(groups[0].lines.length, 1);
 								          assert.equal(groups[0].lines[0].text, '');
 								          assert.equal(groups[0].lines[0].beforeNumber, GrDiffLine.FILE);
 								          assert.equal(groups[0].lines[0].afterNumber, GrDiffLine.FILE);
 								          assert.equal(groups[1].type, GrDiffGroup.Type.CONTEXT_CONTROL);
 								          assert.instanceOf(groups[1].lines[0].contextGroup, GrDiffGroup);
 								          assert.equal(groups[1].lines[0].contextGroup.lines.length, 90);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          for (const l of groups[1].lines[0].contextGroup.lines) {
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								            assert.equal(l.text, content[0].ab[0]);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          }
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
 								          assert.equal(groups[2].type, GrDiffGroup.Type.BOTH);
 								          assert.equal(groups[2].lines.length, context);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          for (const l of groups[2].lines) {
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								            assert.equal(l.text, content[0].ab[0]);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          }
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
 								          assert.equal(groups[3].type, GrDiffGroup.Type.DELTA);
 								          assert.equal(groups[3].lines.length, 1);
 								          assert.equal(groups[3].removes.length, 1);
 								          assert.equal(groups[3].removes[0].text,
 								              'all work and no play make andybons a dull boy');
 								          assert.equal(groups[4].type, GrDiffGroup.Type.BOTH);
 								          assert.equal(groups[4].lines.length, 5);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          for (const l of groups[4].lines) {
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								            assert.equal(l.text, content[2].ab[0]);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          }
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
 								          assert.equal(groups[5].type, GrDiffGroup.Type.DELTA);
 								          assert.equal(groups[5].lines.length, 1);
 								          assert.equal(groups[5].adds.length, 1);
 								          assert.equal(groups[5].adds[0].text, 'elgoog elgoog elgoog');
 								          assert.equal(groups[6].type, GrDiffGroup.Type.BOTH);
 								          assert.equal(groups[6].lines.length, context);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          for (const l of groups[6].lines) {
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								            assert.equal(l.text, content[4].ab[0]);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          }
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
 								          assert.equal(groups[7].type, GrDiffGroup.Type.CONTEXT_CONTROL);
 								          assert.instanceOf(groups[7].lines[0].contextGroup, GrDiffGroup);
 								          assert.equal(groups[7].lines[0].contextGroup.lines.length, 90);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          for (const l of groups[7].lines[0].contextGroup.lines) {
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								            assert.equal(l.text, content[4].ab[0]);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          }
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
 								          done();
 								        });
 								      });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								      test('insert context groups', done => {
 								        const content = [
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								          {a: ['all work and no play make andybons a dull boy']},
 								          {ab: []},
 								          {b: ['elgoog elgoog elgoog']},
 								        ];
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        for (let i = 0; i < 50; i++) {
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								          content[1].ab.push('no tv and no beer make homer go crazy');
 								        }
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        const context = 10;
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								        element.context = context;
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        element.process(content).then(() => {
 								          const groups = element.groups;
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
 								          assert.equal(groups[0].type, GrDiffGroup.Type.BOTH);
 								          assert.equal(groups[0].lines.length, 1);
 								          assert.equal(groups[0].lines[0].text, '');
 								          assert.equal(groups[0].lines[0].beforeNumber, GrDiffLine.FILE);
 								          assert.equal(groups[0].lines[0].afterNumber, GrDiffLine.FILE);
 								          assert.equal(groups[1].type, GrDiffGroup.Type.DELTA);
 								          assert.equal(groups[1].lines.length, 1);
 								          assert.equal(groups[1].removes.length, 1);
 								          assert.equal(groups[1].removes[0].text,
 								              'all work and no play make andybons a dull boy');
 								          assert.equal(groups[2].type, GrDiffGroup.Type.BOTH);
 								          assert.equal(groups[2].lines.length, context);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          for (const l of groups[2].lines) {
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								            assert.equal(l.text, content[1].ab[0]);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          }
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
 								          assert.equal(groups[3].type, GrDiffGroup.Type.CONTEXT_CONTROL);
 								          assert.instanceOf(groups[3].lines[0].contextGroup, GrDiffGroup);
 								          assert.equal(groups[3].lines[0].contextGroup.lines.length, 30);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          for (const l of groups[3].lines[0].contextGroup.lines) {
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								            assert.equal(l.text, content[1].ab[0]);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          }
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
 								          assert.equal(groups[4].type, GrDiffGroup.Type.BOTH);
 								          assert.equal(groups[4].lines.length, context);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          for (const l of groups[4].lines) {
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								            assert.equal(l.text, content[1].ab[0]);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          }
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
 								          assert.equal(groups[5].type, GrDiffGroup.Type.DELTA);
 								          assert.equal(groups[5].lines.length, 1);
 								          assert.equal(groups[5].adds.length, 1);
 								          assert.equal(groups[5].adds[0].text, 'elgoog elgoog elgoog');
 								          done();
 								        });
 								      });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								      test('break up common diff chunks', () => {
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								        element.keyLocations = {
 								          left: {1: true},
 								          right: {10: true},
 								        };
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        const lineNums = {left: 0, right: 0};
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        const content = [
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								          {
 								            ab: [
 								              'Copyright (C) 2015 The Android Open Source Project',
 								              '',
 								              'Licensed under the Apache License, Version 2.0 (the "License");',
 								              'you may not use this file except in compliance with the ' +
 								                  'License.',
 								              'You may obtain a copy of the License at',
 								              '',
 								              'http://www.apache.org/licenses/LICENSE-2.0',
 								              '',
 								              'Unless required by applicable law or agreed to in writing, ',
 								              'software distributed under the License is distributed on an ',
 								              '"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, ',
 								              'either express or implied. See the License for the specific ',
 								              'language governing permissions and limitations under the ' +
 								                  'License.',
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								            ],
 								          },
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								        ];
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        const result =
 								            element._splitCommonGroupsWithComments(content, lineNums);
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								        assert.deepEqual(result, [
 								          {
 								            ab: ['Copyright (C) 2015 The Android Open Source Project'],
 								          },
 								          {
 								            ab: [
 								              '',
 								              'Licensed under the Apache License, Version 2.0 (the "License");',
 								              'you may not use this file except in compliance with the ' +
 								                  'License.',
 								              'You may obtain a copy of the License at',
 								              '',
 								              'http://www.apache.org/licenses/LICENSE-2.0',
 								              '',
 								              'Unless required by applicable law or agreed to in writing, ',
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								            ],
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								          },
 								          {
 								            ab: [
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								              'software distributed under the License is distributed on an '],
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								          },
 								          {
 								            ab: [
 								              '"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, ',
 								              'either express or implied. See the License for the specific ',
 								              'language governing permissions and limitations under the ' +
 								                  'License.',
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								            ],
 								          },
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								        ]);
 								      });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								      test('breaks-down shared chunks w/ whole-file', () => {
 								        const size = 120 * 2 + 5;
 								        const lineNums = {left: 0, right: 0};
 								        const content = [{
 								          ab: _.times(size, () => { return `${Math.random()}`; }),
-												Incremental rendering for large shared groups under full-context

Formerly, incremental rendering had not been applied to shared chunks
because it would break context-grouping logic. However, when the context
is set to the whole file, this problem is averted because the
context-groups are not created. Apply incremental rendering to shared
chunks only when the context is set to whole file.

Change-Id: I8018535ee72e5d4ef499628181298a13e8b20d06

											
										
										
											2017-03-13 13:35:47 -07:00
+								        }];
 								        element.context = -1;
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        const result =
 								            element._splitCommonGroupsWithComments(content, lineNums);
-												Incremental rendering for large shared groups under full-context

Formerly, incremental rendering had not been applied to shared chunks
because it would break context-grouping logic. However, when the context
is set to the whole file, this problem is averted because the
context-groups are not created. Apply incremental rendering to shared
chunks only when the context is set to whole file.

Change-Id: I8018535ee72e5d4ef499628181298a13e8b20d06

											
										
										
											2017-03-13 13:35:47 -07:00
+								        assert.equal(result.length, 2);
-												Improved shared group decomposition

Shared groups were broken down in I8018535ee7 to improve perceived
performance using a diff of Go's go_spec.html as a benchmark. However,
the total render time became slower with this change because the
decomposed groups thrashed the layout.

With this change, shared groups are decomposed into two groups to
achieve the same perceived responsiveness, but balance that with total
render time and avoid needless layouts.

The Maximum group size in increased to 120 to further reduce the number
of groups.

Some performance numbers for the go_spec.html benchmark diff and the
config_dump.json diff indicated in the linked issue.

                        +------------------+--------------+
                        | config_dump.json | go_spec.html |
+-----------------------+------------------+--------------+
| Content Render Before |       83877.2 ms |    7815.2 ms |
+-----------------------+------------------+--------------+
|  Content Render After |       17492.0 ms |    3363.4 ms |
+-----------------------+------------------+--------------+
|        Speedup Factor |          ~4.8    |      ~2.3    |
+-----------------------+------------------+--------------+

Further performance improvements to follow.

Bug: Issue 5778
Change-Id: I97751b7b78b821a794374cbfeecb16d59d5e1c4c

											
										
										
											2017-05-04 10:01:52 -07:00
+								        assert.deepEqual(result[0].ab, content[0].ab.slice(0, 120));
 								        assert.deepEqual(result[1].ab, content[0].ab.slice(120));
-												Incremental rendering for large shared groups under full-context

Formerly, incremental rendering had not been applied to shared chunks
because it would break context-grouping logic. However, when the context
is set to the whole file, this problem is averted because the
context-groups are not created. Apply incremental rendering to shared
chunks only when the context is set to whole file.

Change-Id: I8018535ee72e5d4ef499628181298a13e8b20d06

											
										
										
											2017-03-13 13:35:47 -07:00
+								      });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								      test('does not break-down shared chunks w/ context', () => {
 								        const lineNums = {left: 0, right: 0};
 								        const content = [{
 								          ab: _.times(75, () => { return `${Math.random()}`; }),
-												Incremental rendering for large shared groups under full-context

Formerly, incremental rendering had not been applied to shared chunks
because it would break context-grouping logic. However, when the context
is set to the whole file, this problem is averted because the
context-groups are not created. Apply incremental rendering to shared
chunks only when the context is set to whole file.

Change-Id: I8018535ee72e5d4ef499628181298a13e8b20d06

											
										
										
											2017-03-13 13:35:47 -07:00
+								        }];
 								        element.context = 4;
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        const result =
 								            element._splitCommonGroupsWithComments(content, lineNums);
-												Incremental rendering for large shared groups under full-context

Formerly, incremental rendering had not been applied to shared chunks
because it would break context-grouping logic. However, when the context
is set to the whole file, this problem is averted because the
context-groups are not created. Apply incremental rendering to shared
chunks only when the context is set to whole file.

Change-Id: I8018535ee72e5d4ef499628181298a13e8b20d06

											
										
										
											2017-03-13 13:35:47 -07:00
+								        assert.deepEqual(result, content);
 								      });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								      test('intraline normalization', () => {
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								        // The content and highlights are in the format returned by the Gerrit
 								        // REST API.
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        let content = [
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								          '      <section class="summary">',
 								          '        <gr-linked-text content="' +
 								              '[[_computeCurrentRevisionMessage(change)]]"></gr-linked-text>',
 								          '      </section>',
 								        ];
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        let highlights = [
 								          [31, 34], [42, 26],
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								        ];
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        let results = element._normalizeIntralineHighlights(content,
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								            highlights);
 								        assert.deepEqual(results, [
 								          {
 								            contentIndex: 0,
 								            startIndex: 31,
 								          },
 								          {
 								            contentIndex: 1,
 								            startIndex: 0,
 								            endIndex: 33,
 								          },
 								          {
 								            contentIndex: 1,
 								            startIndex: 75,
 								          },
 								          {
 								            contentIndex: 2,
 								            startIndex: 0,
 								            endIndex: 6,
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          },
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								        ]);
 								        content = [
 								          '        this._path = value.path;',
 								          '',
 								          '        // When navigating away from the page, there is a ' +
 								            'possibility that the',
 								          '        // patch number is no longer a part of the URL ' +
 								            '(say when navigating to',
 								          '        // the top-level change info view) and therefore ' +
 								            'undefined in `params`.',
 								          '        if (!this._patchRange.patchNum) {',
 								        ];
 								        highlights = [
 								          [14, 17],
 								          [11, 70],
 								          [12, 67],
 								          [12, 67],
 								          [14, 29],
 								        ];
 								        results = element._normalizeIntralineHighlights(content, highlights);
 								        assert.deepEqual(results, [
 								          {
 								            contentIndex: 0,
 								            startIndex: 14,
 								            endIndex: 31,
 								          },
 								          {
 								            contentIndex: 2,
 								            startIndex: 8,
 								            endIndex: 78,
 								          },
 								          {
 								            contentIndex: 3,
 								            startIndex: 11,
 								            endIndex: 78,
 								          },
 								          {
 								            contentIndex: 4,
 								            startIndex: 11,
 								            endIndex: 78,
 								          },
 								          {
 								            contentIndex: 5,
 								            startIndex: 12,
 								            endIndex: 41,
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          },
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								        ]);
 								      });
-												Refactor gr-diff-processor to use an asynchronous loop

Modifies the `process` method of gr-diff-processor to traverse diff
content using an asynchronous recursive loop rather than a blocking
for-loop. The async version maintains the promise interface already
established.

Refactored to constrain side-effects to the `process` method. Whereas,
formerly, helper methods in gr-diff-processor both read and wrote the
component's internal state, they are rewritten to be more pure, making
them simpler to understand, test, and invoke asynchronously.

Documentation is added throughout as well as tests for helper functions.

Note that this change only makes the processing step asynchronous.
Upgrading the diff-rendering stage to be non-blocking will come in a
later change.

Change-Id: Ifd50eeb75797b173937890caacc92cad5675fc20

											
										
										
											2016-06-28 10:33:33 -07:00
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								      test('scrolling pauses rendering', () => {
 								        const contentRow = {
-												Pause diff rendering on window scroll

Bug: Issue 4364
Change-Id: If1bc1560fa98b170e776fd0afd9782d8ca38e769

											
										
										
											2016-08-22 16:56:23 -07:00
+								          ab: [
 								            '<!DOCTYPE html>',
 								            '<meta charset="utf-8">',
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          ],
-												Pause diff rendering on window scroll

Bug: Issue 4364
Change-Id: If1bc1560fa98b170e776fd0afd9782d8ca38e769

											
										
										
											2016-08-22 16:56:23 -07:00
+								        };
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        const content = _.times(200, _.constant(contentRow));
-												Pause diff rendering on window scroll

Bug: Issue 4364
Change-Id: If1bc1560fa98b170e776fd0afd9782d8ca38e769

											
										
										
											2016-08-22 16:56:23 -07:00
+								        sandbox.stub(element, 'async');
 								        element._isScrolling = true;
 								        element.process(content);
 								        assert.equal(element.groups.length, 1);
 								        element._isScrolling = false;
 								        element.process(content);
 								        assert.equal(element.groups.length, 33);
 								      });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								      test('image diffs', () => {
 								        const contentRow = {
-												Don't show binary image content & fix image label

Previously there were times when binary data from an image diff would
display. This change adds a check in the diff processor for image diffs
and does not display anything other than the file line in that case.

This change also addresses an issue where the label is calculated too
soon. The image size (if it exists) is supposed to be included as part
of the label, but often this was calculated before the image was done
rendering, so it didn't display.

Bug: Issue 5887
Change-Id: I9cd1ad0c3f2603492d7d84892147bd6852bbae29

											
										
										
											2017-03-29 17:29:17 -07:00
+								          ab: [
 								            '<!DOCTYPE html>',
 								            '<meta charset="utf-8">',
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          ],
-												Don't show binary image content & fix image label

Previously there were times when binary data from an image diff would
display. This change adds a check in the diff processor for image diffs
and does not display anything other than the file line in that case.

This change also addresses an issue where the label is calculated too
soon. The image size (if it exists) is supposed to be included as part
of the label, but often this was calculated before the image was done
rendering, so it didn't display.

Bug: Issue 5887
Change-Id: I9cd1ad0c3f2603492d7d84892147bd6852bbae29

											
										
										
											2017-03-29 17:29:17 -07:00
+								        };
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        const content = _.times(200, _.constant(contentRow));
-												Don't show binary image content & fix image label

Previously there were times when binary data from an image diff would
display. This change adds a check in the diff processor for image diffs
and does not display anything other than the file line in that case.

This change also addresses an issue where the label is calculated too
soon. The image size (if it exists) is supposed to be included as part
of the label, but often this was calculated before the image was done
rendering, so it didn't display.

Bug: Issue 5887
Change-Id: I9cd1ad0c3f2603492d7d84892147bd6852bbae29

											
										
										
											2017-03-29 17:29:17 -07:00
+								        sandbox.stub(element, 'async');
 								        element.process(content, true);
 								        assert.equal(element.groups.length, 1);
 								        // Image diffs don't process content, just the 'FILE' line.
 								        assert.equal(element.groups[0].lines.length, 1);
 								      });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								      suite('gr-diff-processor helpers', () => {
 								        let rows;
-												Refactor gr-diff-processor to use an asynchronous loop

Modifies the `process` method of gr-diff-processor to traverse diff
content using an asynchronous recursive loop rather than a blocking
for-loop. The async version maintains the promise interface already
established.

Refactored to constrain side-effects to the `process` method. Whereas,
formerly, helper methods in gr-diff-processor both read and wrote the
component's internal state, they are rewritten to be more pure, making
them simpler to understand, test, and invoke asynchronously.

Documentation is added throughout as well as tests for helper functions.

Note that this change only makes the processing step asynchronous.
Upgrading the diff-rendering stage to be non-blocking will come in a
later change.

Change-Id: Ifd50eeb75797b173937890caacc92cad5675fc20

											
										
										
											2016-06-28 10:33:33 -07:00
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        setup(() => {
-												Refactor gr-diff-processor to use an asynchronous loop

Modifies the `process` method of gr-diff-processor to traverse diff
content using an asynchronous recursive loop rather than a blocking
for-loop. The async version maintains the promise interface already
established.

Refactored to constrain side-effects to the `process` method. Whereas,
formerly, helper methods in gr-diff-processor both read and wrote the
component's internal state, they are rewritten to be more pure, making
them simpler to understand, test, and invoke asynchronously.

Documentation is added throughout as well as tests for helper functions.

Note that this change only makes the processing step asynchronous.
Upgrading the diff-rendering stage to be non-blocking will come in a
later change.

Change-Id: Ifd50eeb75797b173937890caacc92cad5675fc20

											
										
										
											2016-06-28 10:33:33 -07:00
+								          rows = loremIpsum.split(' ');
 								        });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        test('_sharedGroupsFromRows WHOLE_FILE', () => {
 								          const context = WHOLE_FILE;
 								          const lineNumbers = {left: 10, right: 100};
 								          const result = element._sharedGroupsFromRows(
-												Refactor gr-diff-processor to use an asynchronous loop

Modifies the `process` method of gr-diff-processor to traverse diff
content using an asynchronous recursive loop rather than a blocking
for-loop. The async version maintains the promise interface already
established.

Refactored to constrain side-effects to the `process` method. Whereas,
formerly, helper methods in gr-diff-processor both read and wrote the
component's internal state, they are rewritten to be more pure, making
them simpler to understand, test, and invoke asynchronously.

Documentation is added throughout as well as tests for helper functions.

Note that this change only makes the processing step asynchronous.
Upgrading the diff-rendering stage to be non-blocking will come in a
later change.

Change-Id: Ifd50eeb75797b173937890caacc92cad5675fc20

											
										
										
											2016-06-28 10:33:33 -07:00
+								              rows, context, lineNumbers.left, lineNumbers.right, null);
 								          // Results in one, uncollapsed group with all rows.
 								          assert.equal(result.length, 1);
 								          assert.equal(result[0].type, GrDiffGroup.Type.BOTH);
 								          assert.equal(result[0].lines.length, rows.length);
 								          // Line numbers are set correctly.
 								          assert.equal(result[0].lines[0].beforeNumber, lineNumbers.left + 1);
 								          assert.equal(result[0].lines[0].afterNumber, lineNumbers.right + 1);
 								          assert.equal(result[0].lines[rows.length - 1].beforeNumber,
 								              lineNumbers.left + rows.length);
 								          assert.equal(result[0].lines[rows.length - 1].afterNumber,
 								              lineNumbers.right + rows.length);
 								        });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        test('_sharedGroupsFromRows context', () => {
 								          const context = 10;
 								          const result = element._sharedGroupsFromRows(
-												Refactor gr-diff-processor to use an asynchronous loop

Modifies the `process` method of gr-diff-processor to traverse diff
content using an asynchronous recursive loop rather than a blocking
for-loop. The async version maintains the promise interface already
established.

Refactored to constrain side-effects to the `process` method. Whereas,
formerly, helper methods in gr-diff-processor both read and wrote the
component's internal state, they are rewritten to be more pure, making
them simpler to understand, test, and invoke asynchronously.

Documentation is added throughout as well as tests for helper functions.

Note that this change only makes the processing step asynchronous.
Upgrading the diff-rendering stage to be non-blocking will come in a
later change.

Change-Id: Ifd50eeb75797b173937890caacc92cad5675fc20

											
										
										
											2016-06-28 10:33:33 -07:00
+								              rows, context, 10, 100, null);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          const expectedCollapseSize = rows.length - 2 * context;
-												Refactor gr-diff-processor to use an asynchronous loop

Modifies the `process` method of gr-diff-processor to traverse diff
content using an asynchronous recursive loop rather than a blocking
for-loop. The async version maintains the promise interface already
established.

Refactored to constrain side-effects to the `process` method. Whereas,
formerly, helper methods in gr-diff-processor both read and wrote the
component's internal state, they are rewritten to be more pure, making
them simpler to understand, test, and invoke asynchronously.

Documentation is added throughout as well as tests for helper functions.

Note that this change only makes the processing step asynchronous.
Upgrading the diff-rendering stage to be non-blocking will come in a
later change.

Change-Id: Ifd50eeb75797b173937890caacc92cad5675fc20

											
										
										
											2016-06-28 10:33:33 -07:00
 								          assert.equal(result.length, 3, 'Results in three groups');
 								          // The first and last are uncollapsed context, whereas the middle has
 								          // a single context-control line.
 								          assert.equal(result[0].lines.length, context);
 								          assert.equal(result[1].lines.length, 1);
 								          assert.equal(result[2].lines.length, context);
 								          // The collapsed group has the hidden lines as its context group.
 								          assert.equal(result[1].lines[0].contextGroup.lines.length,
 								              expectedCollapseSize);
 								        });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        test('_sharedGroupsFromRows first', () => {
 								          const context = 10;
 								          const result = element._sharedGroupsFromRows(
-												Refactor gr-diff-processor to use an asynchronous loop

Modifies the `process` method of gr-diff-processor to traverse diff
content using an asynchronous recursive loop rather than a blocking
for-loop. The async version maintains the promise interface already
established.

Refactored to constrain side-effects to the `process` method. Whereas,
formerly, helper methods in gr-diff-processor both read and wrote the
component's internal state, they are rewritten to be more pure, making
them simpler to understand, test, and invoke asynchronously.

Documentation is added throughout as well as tests for helper functions.

Note that this change only makes the processing step asynchronous.
Upgrading the diff-rendering stage to be non-blocking will come in a
later change.

Change-Id: Ifd50eeb75797b173937890caacc92cad5675fc20

											
										
										
											2016-06-28 10:33:33 -07:00
+								              rows, context, 10, 100, 'first');
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          const expectedCollapseSize = rows.length - context;
-												Refactor gr-diff-processor to use an asynchronous loop

Modifies the `process` method of gr-diff-processor to traverse diff
content using an asynchronous recursive loop rather than a blocking
for-loop. The async version maintains the promise interface already
established.

Refactored to constrain side-effects to the `process` method. Whereas,
formerly, helper methods in gr-diff-processor both read and wrote the
component's internal state, they are rewritten to be more pure, making
them simpler to understand, test, and invoke asynchronously.

Documentation is added throughout as well as tests for helper functions.

Note that this change only makes the processing step asynchronous.
Upgrading the diff-rendering stage to be non-blocking will come in a
later change.

Change-Id: Ifd50eeb75797b173937890caacc92cad5675fc20

											
										
										
											2016-06-28 10:33:33 -07:00
 								          assert.equal(result.length, 2, 'Results in two groups');
 								          // Only the first group is collapsed.
 								          assert.equal(result[0].lines.length, 1);
 								          assert.equal(result[1].lines.length, context);
 								          // The collapsed group has the hidden lines as its context group.
 								          assert.equal(result[0].lines[0].contextGroup.lines.length,
 								              expectedCollapseSize);
 								        });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        test('_sharedGroupsFromRows few-rows', () => {
-												Refactor gr-diff-processor to use an asynchronous loop

Modifies the `process` method of gr-diff-processor to traverse diff
content using an asynchronous recursive loop rather than a blocking
for-loop. The async version maintains the promise interface already
established.

Refactored to constrain side-effects to the `process` method. Whereas,
formerly, helper methods in gr-diff-processor both read and wrote the
component's internal state, they are rewritten to be more pure, making
them simpler to understand, test, and invoke asynchronously.

Documentation is added throughout as well as tests for helper functions.

Note that this change only makes the processing step asynchronous.
Upgrading the diff-rendering stage to be non-blocking will come in a
later change.

Change-Id: Ifd50eeb75797b173937890caacc92cad5675fc20

											
										
										
											2016-06-28 10:33:33 -07:00
+								          // Only ten rows.
 								          rows = rows.slice(0, 10);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          const context = 10;
 								          const result = element._sharedGroupsFromRows(
-												Refactor gr-diff-processor to use an asynchronous loop

Modifies the `process` method of gr-diff-processor to traverse diff
content using an asynchronous recursive loop rather than a blocking
for-loop. The async version maintains the promise interface already
established.

Refactored to constrain side-effects to the `process` method. Whereas,
formerly, helper methods in gr-diff-processor both read and wrote the
component's internal state, they are rewritten to be more pure, making
them simpler to understand, test, and invoke asynchronously.

Documentation is added throughout as well as tests for helper functions.

Note that this change only makes the processing step asynchronous.
Upgrading the diff-rendering stage to be non-blocking will come in a
later change.

Change-Id: Ifd50eeb75797b173937890caacc92cad5675fc20

											
										
										
											2016-06-28 10:33:33 -07:00
+								              rows, context, 10, 100, 'first');
 								          // Results in one uncollapsed group with all rows.
 								          assert.equal(result.length, 1, 'Results in one group');
 								          assert.equal(result[0].lines.length, rows.length);
 								        });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        test('_sharedGroupsFromRows no single line collapse', () => {
-												Prevent single-line collapsed common groups

When the diff processor collapses shared groups based on the user
context preference, it would sometimes collapse a single line, resulting
in a common group labeled "Show 1 common line" which takes up exactly
as much space in the diff view as the line itself. Moreover, the GWT UI
does not collapse single line common sections in this way (but does when
there are two or more lines).

Sets the threshold to collapse at least two lines and encodes this in a
test.

Bug: Issue 4721
Change-Id: I8a3a8556fd66a313eacc361379612c700d7ae070

											
										
										
											2016-10-12 10:45:42 -07:00
+								          rows = rows.slice(0, 7);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          const context = 3;
 								          const result = element._sharedGroupsFromRows(
-												Prevent single-line collapsed common groups

When the diff processor collapses shared groups based on the user
context preference, it would sometimes collapse a single line, resulting
in a common group labeled "Show 1 common line" which takes up exactly
as much space in the diff view as the line itself. Moreover, the GWT UI
does not collapse single line common sections in this way (but does when
there are two or more lines).

Sets the threshold to collapse at least two lines and encodes this in a
test.

Bug: Issue 4721
Change-Id: I8a3a8556fd66a313eacc361379612c700d7ae070

											
										
										
											2016-10-12 10:45:42 -07:00
+								              rows, context, 10, 100);
 								          // Results in one uncollapsed group with all rows.
 								          assert.equal(result.length, 1, 'Results in one group');
 								          assert.equal(result[0].lines.length, rows.length);
 								        });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        test('_deltaLinesFromRows', () => {
 								          const startLineNum = 10;
 								          let result = element._deltaLinesFromRows(GrDiffLine.Type.ADD, rows,
-												Refactor gr-diff-processor to use an asynchronous loop

Modifies the `process` method of gr-diff-processor to traverse diff
content using an asynchronous recursive loop rather than a blocking
for-loop. The async version maintains the promise interface already
established.

Refactored to constrain side-effects to the `process` method. Whereas,
formerly, helper methods in gr-diff-processor both read and wrote the
component's internal state, they are rewritten to be more pure, making
them simpler to understand, test, and invoke asynchronously.

Documentation is added throughout as well as tests for helper functions.

Note that this change only makes the processing step asynchronous.
Upgrading the diff-rendering stage to be non-blocking will come in a
later change.

Change-Id: Ifd50eeb75797b173937890caacc92cad5675fc20

											
										
										
											2016-06-28 10:33:33 -07:00
+								              startLineNum);
 								          assert.equal(result.length, rows.length);
 								          assert.equal(result[0].type, GrDiffLine.Type.ADD);
 								          assert.equal(result[0].afterNumber, startLineNum + 1);
 								          assert.notOk(result[0].beforeNumber);
 								          assert.equal(result[result.length - 1].afterNumber,
 								              startLineNum + rows.length);
 								          assert.notOk(result[result.length - 1].beforeNumber);
 								          result = element._deltaLinesFromRows(GrDiffLine.Type.REMOVE, rows,
 								              startLineNum);
 								          assert.equal(result.length, rows.length);
 								          assert.equal(result[0].type, GrDiffLine.Type.REMOVE);
 								          assert.equal(result[0].beforeNumber, startLineNum + 1);
 								          assert.notOk(result[0].afterNumber);
 								          assert.equal(result[result.length - 1].beforeNumber,
 								              startLineNum + rows.length);
 								          assert.notOk(result[result.length - 1].afterNumber);
 								        });
 								      });
-												Applies optimizations to diff comment DOM attachment

A source of latency when creating diff comments in large diffs is the
work needed to reflow the diff DOM to make room for the new comment.
This is particularly evident when adding comments to new files because
the diff is built as an addition group representing the entire file, so
the comment causes a reflow on every subsequent line.

This change optimizes this process in three ways.

* **Limit the size of ADD & REMOVE groups:** The diff processor will now
  break an add or a remove chunk into a series of smaller chunks of the
  same kind. This is controlled by the MAX_GROUP_SIZE constant. In this
  way the number of nodes that need to be reflowed when a comment is
  added to an add or remove group is limited to the number of subsequent
  lines in that group plus the subsequent number of groups.
* **GPU optimize group in general:** Adds CSS properties to diff TBODY
  elements (which correspond to groups, for the most part) that trigger
  GPU acceleration when available.
* **Apply `table-layout: fixed;`** This style speeds up table reflow in
  general.

Change-Id: Ie0e3665b7752fec67f7123cfae70ae99e6f67521

											
										
										
											2016-08-05 15:56:33 -07:00
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								      suite('_breakdown*', () => {
 								        test('_breakdownGroup breaks down additions', () => {
-												Applies optimizations to diff comment DOM attachment

A source of latency when creating diff comments in large diffs is the
work needed to reflow the diff DOM to make room for the new comment.
This is particularly evident when adding comments to new files because
the diff is built as an addition group representing the entire file, so
the comment causes a reflow on every subsequent line.

This change optimizes this process in three ways.

* **Limit the size of ADD & REMOVE groups:** The diff processor will now
  break an add or a remove chunk into a series of smaller chunks of the
  same kind. This is controlled by the MAX_GROUP_SIZE constant. In this
  way the number of nodes that need to be reflowed when a comment is
  added to an add or remove group is limited to the number of subsequent
  lines in that group plus the subsequent number of groups.
* **GPU optimize group in general:** Adds CSS properties to diff TBODY
  elements (which correspond to groups, for the most part) that trigger
  GPU acceleration when available.
* **Apply `table-layout: fixed;`** This style speeds up table reflow in
  general.

Change-Id: Ie0e3665b7752fec67f7123cfae70ae99e6f67521

											
										
										
											2016-08-05 15:56:33 -07:00
+								          sandbox.spy(element, '_breakdown');
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          const chunk = {b: ['blah', 'blah', 'blah']};
 								          const result = element._breakdownGroup(chunk);
-												Applies optimizations to diff comment DOM attachment

A source of latency when creating diff comments in large diffs is the
work needed to reflow the diff DOM to make room for the new comment.
This is particularly evident when adding comments to new files because
the diff is built as an addition group representing the entire file, so
the comment causes a reflow on every subsequent line.

This change optimizes this process in three ways.

* **Limit the size of ADD & REMOVE groups:** The diff processor will now
  break an add or a remove chunk into a series of smaller chunks of the
  same kind. This is controlled by the MAX_GROUP_SIZE constant. In this
  way the number of nodes that need to be reflowed when a comment is
  added to an add or remove group is limited to the number of subsequent
  lines in that group plus the subsequent number of groups.
* **GPU optimize group in general:** Adds CSS properties to diff TBODY
  elements (which correspond to groups, for the most part) that trigger
  GPU acceleration when available.
* **Apply `table-layout: fixed;`** This style speeds up table reflow in
  general.

Change-Id: Ie0e3665b7752fec67f7123cfae70ae99e6f67521

											
										
										
											2016-08-05 15:56:33 -07:00
+								          assert.deepEqual(result, [chunk]);
 								          assert.isTrue(element._breakdown.called);
 								        });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        test('_breakdown common case', () => {
 								          const array = 'Lorem ipsum dolor sit amet, suspendisse inceptos'
-												Applies optimizations to diff comment DOM attachment

A source of latency when creating diff comments in large diffs is the
work needed to reflow the diff DOM to make room for the new comment.
This is particularly evident when adding comments to new files because
the diff is built as an addition group representing the entire file, so
the comment causes a reflow on every subsequent line.

This change optimizes this process in three ways.

* **Limit the size of ADD & REMOVE groups:** The diff processor will now
  break an add or a remove chunk into a series of smaller chunks of the
  same kind. This is controlled by the MAX_GROUP_SIZE constant. In this
  way the number of nodes that need to be reflowed when a comment is
  added to an add or remove group is limited to the number of subsequent
  lines in that group plus the subsequent number of groups.
* **GPU optimize group in general:** Adds CSS properties to diff TBODY
  elements (which correspond to groups, for the most part) that trigger
  GPU acceleration when available.
* **Apply `table-layout: fixed;`** This style speeds up table reflow in
  general.

Change-Id: Ie0e3665b7752fec67f7123cfae70ae99e6f67521

											
										
										
											2016-08-05 15:56:33 -07:00
+								              .split(' ');
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          const size = 3;
-												Applies optimizations to diff comment DOM attachment

A source of latency when creating diff comments in large diffs is the
work needed to reflow the diff DOM to make room for the new comment.
This is particularly evident when adding comments to new files because
the diff is built as an addition group representing the entire file, so
the comment causes a reflow on every subsequent line.

This change optimizes this process in three ways.

* **Limit the size of ADD & REMOVE groups:** The diff processor will now
  break an add or a remove chunk into a series of smaller chunks of the
  same kind. This is controlled by the MAX_GROUP_SIZE constant. In this
  way the number of nodes that need to be reflowed when a comment is
  added to an add or remove group is limited to the number of subsequent
  lines in that group plus the subsequent number of groups.
* **GPU optimize group in general:** Adds CSS properties to diff TBODY
  elements (which correspond to groups, for the most part) that trigger
  GPU acceleration when available.
* **Apply `table-layout: fixed;`** This style speeds up table reflow in
  general.

Change-Id: Ie0e3665b7752fec67f7123cfae70ae99e6f67521

											
										
										
											2016-08-05 15:56:33 -07:00
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          const result = element._breakdown(array, size);
-												Applies optimizations to diff comment DOM attachment

A source of latency when creating diff comments in large diffs is the
work needed to reflow the diff DOM to make room for the new comment.
This is particularly evident when adding comments to new files because
the diff is built as an addition group representing the entire file, so
the comment causes a reflow on every subsequent line.

This change optimizes this process in three ways.

* **Limit the size of ADD & REMOVE groups:** The diff processor will now
  break an add or a remove chunk into a series of smaller chunks of the
  same kind. This is controlled by the MAX_GROUP_SIZE constant. In this
  way the number of nodes that need to be reflowed when a comment is
  added to an add or remove group is limited to the number of subsequent
  lines in that group plus the subsequent number of groups.
* **GPU optimize group in general:** Adds CSS properties to diff TBODY
  elements (which correspond to groups, for the most part) that trigger
  GPU acceleration when available.
* **Apply `table-layout: fixed;`** This style speeds up table reflow in
  general.

Change-Id: Ie0e3665b7752fec67f7123cfae70ae99e6f67521

											
										
										
											2016-08-05 15:56:33 -07:00
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          for (const subResult of result) {
-												Applies optimizations to diff comment DOM attachment

A source of latency when creating diff comments in large diffs is the
work needed to reflow the diff DOM to make room for the new comment.
This is particularly evident when adding comments to new files because
the diff is built as an addition group representing the entire file, so
the comment causes a reflow on every subsequent line.

This change optimizes this process in three ways.

* **Limit the size of ADD & REMOVE groups:** The diff processor will now
  break an add or a remove chunk into a series of smaller chunks of the
  same kind. This is controlled by the MAX_GROUP_SIZE constant. In this
  way the number of nodes that need to be reflowed when a comment is
  added to an add or remove group is limited to the number of subsequent
  lines in that group plus the subsequent number of groups.
* **GPU optimize group in general:** Adds CSS properties to diff TBODY
  elements (which correspond to groups, for the most part) that trigger
  GPU acceleration when available.
* **Apply `table-layout: fixed;`** This style speeds up table reflow in
  general.

Change-Id: Ie0e3665b7752fec67f7123cfae70ae99e6f67521

											
										
										
											2016-08-05 15:56:33 -07:00
+								            assert.isAtMost(subResult.length, size);
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          }
 								          const flattened = result
 								              .reduce((a, b) => { return a.concat(b); }, []);
-												Applies optimizations to diff comment DOM attachment

A source of latency when creating diff comments in large diffs is the
work needed to reflow the diff DOM to make room for the new comment.
This is particularly evident when adding comments to new files because
the diff is built as an addition group representing the entire file, so
the comment causes a reflow on every subsequent line.

This change optimizes this process in three ways.

* **Limit the size of ADD & REMOVE groups:** The diff processor will now
  break an add or a remove chunk into a series of smaller chunks of the
  same kind. This is controlled by the MAX_GROUP_SIZE constant. In this
  way the number of nodes that need to be reflowed when a comment is
  added to an add or remove group is limited to the number of subsequent
  lines in that group plus the subsequent number of groups.
* **GPU optimize group in general:** Adds CSS properties to diff TBODY
  elements (which correspond to groups, for the most part) that trigger
  GPU acceleration when available.
* **Apply `table-layout: fixed;`** This style speeds up table reflow in
  general.

Change-Id: Ie0e3665b7752fec67f7123cfae70ae99e6f67521

											
										
										
											2016-08-05 15:56:33 -07:00
+								          assert.deepEqual(flattened, array);
 								        });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        test('_breakdown smaller than size', () => {
 								          const array = 'Lorem ipsum dolor sit amet, suspendisse inceptos'
-												Applies optimizations to diff comment DOM attachment

A source of latency when creating diff comments in large diffs is the
work needed to reflow the diff DOM to make room for the new comment.
This is particularly evident when adding comments to new files because
the diff is built as an addition group representing the entire file, so
the comment causes a reflow on every subsequent line.

This change optimizes this process in three ways.

* **Limit the size of ADD & REMOVE groups:** The diff processor will now
  break an add or a remove chunk into a series of smaller chunks of the
  same kind. This is controlled by the MAX_GROUP_SIZE constant. In this
  way the number of nodes that need to be reflowed when a comment is
  added to an add or remove group is limited to the number of subsequent
  lines in that group plus the subsequent number of groups.
* **GPU optimize group in general:** Adds CSS properties to diff TBODY
  elements (which correspond to groups, for the most part) that trigger
  GPU acceleration when available.
* **Apply `table-layout: fixed;`** This style speeds up table reflow in
  general.

Change-Id: Ie0e3665b7752fec67f7123cfae70ae99e6f67521

											
										
										
											2016-08-05 15:56:33 -07:00
+								              .split(' ');
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          const size = 10;
 								          const expected = [array];
-												Applies optimizations to diff comment DOM attachment

A source of latency when creating diff comments in large diffs is the
work needed to reflow the diff DOM to make room for the new comment.
This is particularly evident when adding comments to new files because
the diff is built as an addition group representing the entire file, so
the comment causes a reflow on every subsequent line.

This change optimizes this process in three ways.

* **Limit the size of ADD & REMOVE groups:** The diff processor will now
  break an add or a remove chunk into a series of smaller chunks of the
  same kind. This is controlled by the MAX_GROUP_SIZE constant. In this
  way the number of nodes that need to be reflowed when a comment is
  added to an add or remove group is limited to the number of subsequent
  lines in that group plus the subsequent number of groups.
* **GPU optimize group in general:** Adds CSS properties to diff TBODY
  elements (which correspond to groups, for the most part) that trigger
  GPU acceleration when available.
* **Apply `table-layout: fixed;`** This style speeds up table reflow in
  general.

Change-Id: Ie0e3665b7752fec67f7123cfae70ae99e6f67521

											
										
										
											2016-08-05 15:56:33 -07:00
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          const result = element._breakdown(array, size);
-												Applies optimizations to diff comment DOM attachment

A source of latency when creating diff comments in large diffs is the
work needed to reflow the diff DOM to make room for the new comment.
This is particularly evident when adding comments to new files because
the diff is built as an addition group representing the entire file, so
the comment causes a reflow on every subsequent line.

This change optimizes this process in three ways.

* **Limit the size of ADD & REMOVE groups:** The diff processor will now
  break an add or a remove chunk into a series of smaller chunks of the
  same kind. This is controlled by the MAX_GROUP_SIZE constant. In this
  way the number of nodes that need to be reflowed when a comment is
  added to an add or remove group is limited to the number of subsequent
  lines in that group plus the subsequent number of groups.
* **GPU optimize group in general:** Adds CSS properties to diff TBODY
  elements (which correspond to groups, for the most part) that trigger
  GPU acceleration when available.
* **Apply `table-layout: fixed;`** This style speeds up table reflow in
  general.

Change-Id: Ie0e3665b7752fec67f7123cfae70ae99e6f67521

											
										
										
											2016-08-05 15:56:33 -07:00
 								          assert.deepEqual(result, expected);
 								        });
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								        test('_breakdown empty', () => {
 								          const array = [];
 								          const size = 10;
 								          const expected = [];
-												Applies optimizations to diff comment DOM attachment

A source of latency when creating diff comments in large diffs is the
work needed to reflow the diff DOM to make room for the new comment.
This is particularly evident when adding comments to new files because
the diff is built as an addition group representing the entire file, so
the comment causes a reflow on every subsequent line.

This change optimizes this process in three ways.

* **Limit the size of ADD & REMOVE groups:** The diff processor will now
  break an add or a remove chunk into a series of smaller chunks of the
  same kind. This is controlled by the MAX_GROUP_SIZE constant. In this
  way the number of nodes that need to be reflowed when a comment is
  added to an add or remove group is limited to the number of subsequent
  lines in that group plus the subsequent number of groups.
* **GPU optimize group in general:** Adds CSS properties to diff TBODY
  elements (which correspond to groups, for the most part) that trigger
  GPU acceleration when available.
* **Apply `table-layout: fixed;`** This style speeds up table reflow in
  general.

Change-Id: Ie0e3665b7752fec67f7123cfae70ae99e6f67521

											
										
										
											2016-08-05 15:56:33 -07:00
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								          const result = element._breakdown(array, size);
-												Applies optimizations to diff comment DOM attachment

A source of latency when creating diff comments in large diffs is the
work needed to reflow the diff DOM to make room for the new comment.
This is particularly evident when adding comments to new files because
the diff is built as an addition group representing the entire file, so
the comment causes a reflow on every subsequent line.

This change optimizes this process in three ways.

* **Limit the size of ADD & REMOVE groups:** The diff processor will now
  break an add or a remove chunk into a series of smaller chunks of the
  same kind. This is controlled by the MAX_GROUP_SIZE constant. In this
  way the number of nodes that need to be reflowed when a comment is
  added to an add or remove group is limited to the number of subsequent
  lines in that group plus the subsequent number of groups.
* **GPU optimize group in general:** Adds CSS properties to diff TBODY
  elements (which correspond to groups, for the most part) that trigger
  GPU acceleration when available.
* **Apply `table-layout: fixed;`** This style speeds up table reflow in
  general.

Change-Id: Ie0e3665b7752fec67f7123cfae70ae99e6f67521

											
										
										
											2016-08-05 15:56:33 -07:00
 								          assert.deepEqual(result, expected);
 								        });
 								      });
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								    });
-												Cancel diff processing when the diff processor is detached

Bug: Issue 4730
Change-Id: I50cae3c2c59b447befdccde3fcb4bf4a7dadcae8

											
										
										
											2016-10-07 16:56:43 -07:00
-												ES6ify /gr-diff-processor/*

Prior change was reverted due to incorrect modification of lint config.

Bug: Issue 6179
Change-Id: Ieb795403ffa86752d41ae39a4b963e7a1b42b573

											
										
										
											2017-05-16 14:28:28 -07:00
+								    test('detaching cancels', () => {
-												Cancel diff processing when the diff processor is detached

Bug: Issue 4730
Change-Id: I50cae3c2c59b447befdccde3fcb4bf4a7dadcae8

											
										
										
											2016-10-07 16:56:43 -07:00
+								      element = fixture('basic');
 								      sandbox.stub(element, 'cancel');
 								      element.detached();
 								      assert(element.cancel.called);
 								    });
-												Separates diff processing from diff building

Moves the diff-processing functionality of the gr-diff-builder component
into a new gr-diff-processor component which exposes a promise-based
interface. This is step one of creating an asynchronous (non-blocking)
diff rendering system.

As much as possible, this change is a transfer of code (with tests) from
one component to another, making it easier to verify that functionality
has not changed. Cleanup of the code, and refactoring it into a
more-testable form will come with later changes.

Feature: Issue 3916
Change-Id: I875b03b20bf953b128cbe3c5001ba1f8eba12c61

											
										
										
											2016-06-27 12:19:21 -07:00
+								  });
 								</script>