gerrit/polygerrit-ui/app/elements/diff/gr-diff/gr-diff_test.html

<!DOCTYPE html>
<!--
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.
-->

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

<script src="../../../bower_components/webcomponentsjs/webcomponents.min.js"></script>
<script src="../../../bower_components/web-component-tester/browser.js"></script>
<script src="../../../scripts/util.js"></script>

<link rel="import" href="../../../bower_components/iron-test-helpers/iron-test-helpers.html">
<link rel="import" href="gr-diff.html">

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

<script>
  suite('gr-diff tests', function() {
    var element;
    var sandbox;

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

    teardown(function() {
      sandbox.restore();
    });

    suite('not logged in', function() {
      setup(function() {
        stub('gr-rest-api-interface', {
          getLoggedIn: function() { return Promise.resolve(false); },
        });
        element = fixture('basic');
      });

      test('toggleLeftDiff', function() {
        element.toggleLeftDiff();
        assert.isTrue(element.classList.contains('no-left'));
        element.toggleLeftDiff();
        assert.isFalse(element.classList.contains('no-left'));
      });

      test('view does not start with displayLine classList', function() {
        assert.isFalse(
            element.$$('.diffContainer').classList.contains('displayLine'));
      });

      test('displayLine class added called when displayLine is true',
          function() {
        var spy = sandbox.spy(element, '_computeContainerClass');
        element.displayLine = true;
        assert.isTrue(spy.called);
        assert.isTrue(
            element.$$('.diffContainer').classList.contains('displayLine'));
      });

      test('get drafts', function(done) {
        element.patchRange = {basePatchNum: 0, patchNum: 0};

        var getDraftsStub = sandbox.stub(element.$.restAPI, 'getDiffDrafts');
        element._getDiffDrafts().then(function(result) {
          assert.deepEqual(result, {baseComments: [], comments: []});
          sinon.assert.notCalled(getDraftsStub);
          done();
        });
      });

      test('get robot comments', function(done) {
        element.patchRange = {basePatchNum: 0, patchNum: 0};

        var getDraftsStub = sandbox.stub(element.$.restAPI,
            'getDiffRobotComments');
        element._getDiffDrafts().then(function(result) {
          assert.deepEqual(result, {baseComments: [], comments: []});
          sinon.assert.notCalled(getDraftsStub);
          done();
        });
      });

      test('loads files weblinks', function(done) {
        var diffStub = sandbox.stub(element.$.restAPI, 'getDiff').returns(
            Promise.resolve({
              meta_a: {
                web_links: 'foo',
              },
              meta_b: {
                web_links: 'bar',
              },
            }));
        element.patchRange = {};
        element._getDiff().then(function() {
          assert.deepEqual(element.filesWeblinks, {
            meta_a: 'foo',
            meta_b: 'bar',
          });
          done();
        });
      });

      test('remove comment', function() {
        element._comments = {
          meta: {
            changeNum: '42',
            patchRange: {
              basePatchNum: 'PARENT',
              patchNum: 3,
            },
            path: '/path/to/foo',
            projectConfig: {foo: 'bar'},
          },
          left: [
            {id: 'bc1', side: 'PARENT', __commentSide: 'left'},
            {id: 'bc2', side: 'PARENT', __commentSide: 'left'},
            {id: 'bd1', __draft: true, side: 'PARENT', __commentSide: 'left'},
            {id: 'bd2', __draft: true, side: 'PARENT', __commentSide: 'left'},
          ],
          right: [
            {id: 'c1', __commentSide: 'right'},
            {id: 'c2', __commentSide: 'right'},
            {id: 'd1', __draft: true, __commentSide: 'right'},
            {id: 'd2', __draft: true, __commentSide: 'right'},
          ],
        };

        element._removeComment({});
        // Using JSON.stringify because Safari 9.1 (11601.5.17.1) doesn’t seem
        // to believe that one object deepEquals another even when they do :-/.
        assert.equal(JSON.stringify(element._comments), JSON.stringify({
          meta: {
            changeNum: '42',
            patchRange: {
              basePatchNum: 'PARENT',
              patchNum: 3,
            },
            path: '/path/to/foo',
            projectConfig: {foo: 'bar'},
          },
          left: [
            {id: 'bc1', side: 'PARENT', __commentSide: 'left'},
            {id: 'bc2', side: 'PARENT', __commentSide: 'left'},
            {id: 'bd1', __draft: true, side: 'PARENT', __commentSide: 'left'},
            {id: 'bd2', __draft: true, side: 'PARENT', __commentSide: 'left'},
          ],
          right: [
            {id: 'c1', __commentSide: 'right'},
            {id: 'c2', __commentSide: 'right'},
            {id: 'd1', __draft: true, __commentSide: 'right'},
            {id: 'd2', __draft: true, __commentSide: 'right'},
          ],
        }));

        element._removeComment({id: 'bc2', side: 'PARENT',
            __commentSide: 'left'});
        assert.deepEqual(element._comments, {
          meta: {
            changeNum: '42',
            patchRange: {
              basePatchNum: 'PARENT',
              patchNum: 3,
            },
            path: '/path/to/foo',
            projectConfig: {foo: 'bar'},
          },
          left: [
            {id: 'bc1', side: 'PARENT', __commentSide: 'left'},
            {id: 'bd1', __draft: true, side: 'PARENT', __commentSide: 'left'},
            {id: 'bd2', __draft: true, side: 'PARENT', __commentSide: 'left'},
          ],
          right: [
            {id: 'c1', __commentSide: 'right'},
            {id: 'c2', __commentSide: 'right'},
            {id: 'd1', __draft: true, __commentSide: 'right'},
            {id: 'd2', __draft: true, __commentSide: 'right'},
          ],
        });

        element._removeComment({id: 'd2', __commentSide: 'right'});
        assert.deepEqual(element._comments, {
          meta: {
            changeNum: '42',
            patchRange: {
              basePatchNum: 'PARENT',
              patchNum: 3,
            },
            path: '/path/to/foo',
            projectConfig: {foo: 'bar'},
          },
          left: [
            {id: 'bc1', side: 'PARENT', __commentSide: 'left'},
            {id: 'bd1', __draft: true, side: 'PARENT', __commentSide: 'left'},
            {id: 'bd2', __draft: true, side: 'PARENT', __commentSide: 'left'},
          ],
          right: [
            {id: 'c1', __commentSide: 'right'},
            {id: 'c2', __commentSide: 'right'},
            {id: 'd1', __draft: true, __commentSide: 'right'},
          ],
        });
      });

      test('thread groups', function() {
        var contentEl = document.createElement('div');
        var rangeToCheck = 'line-left';
        var commentSide = 'left';
        var patchNum = 1;
        var side = 'PARENT';
        var range = {
          startLine: 1,
          startChar: 1,
          endLine: 1,
          endChar: 2,
        };

        element.changeNum = 123;
        element.patchRange = {basePatchNum: 1, patchNum: 2};
        element.path = 'file.txt';

        sandbox.stub(element.$.diffBuilder, 'createCommentThreadGroup',
            function() {
          return document.createElement('gr-diff-comment-thread-group');
        });

        // No thread groups.
        assert.isNotOk(element._getThreadGroupForLine(contentEl));

        // A thread group gets created.
        assert.isOk(element._getOrCreateThreadAtLineRange(contentEl, patchNum,
            commentSide, side));

        // Try to fetch a thread with a different range.
        range = {
          startLine: 1,
          startChar: 1,
          endLine: 1,
          endChar: 3,
        };

        assert.isOk(element._getOrCreateThreadAtLineRange(
            contentEl, patchNum, commentSide, side, range));
        // The new thread group can be fetched.
        assert.isOk(element._getThreadGroupForLine(contentEl));

        assert.equal(contentEl.querySelectorAll(
            'gr-diff-comment-thread-group').length, 1);

        var threadGroup = contentEl.querySelector(
            'gr-diff-comment-thread-group');
        var threadLength = Polymer.dom(threadGroup.root).
              querySelectorAll('gr-diff-comment-thread').length;
        assert.equal(threadLength, 2);
      });

      test('renders image diffs', function(done) {
        var mockDiff = {
          meta_a: {name: 'carrot.jpg', content_type: 'image/jpeg', lines: 66},
          meta_b: {name: 'carrot.jpg', content_type: 'image/jpeg', lines: 560},
          intraline_status: 'OK',
          change_type: 'MODIFIED',
          diff_header: [
            'diff --git a/carrot.jpg b/carrot.jpg',
            'index 2adc47d..f9c2f2c 100644',
            '--- a/carrot.jpg',
            '+++ b/carrot.jpg',
            'Binary files differ',
          ],
          content: [{skip: 66}],
          binary: true,
        };
        var mockFile1 = {
          body: 'Qk06AAAAAAAAADYAAAAoAAAAAQAAAP////8BACAAAAAAAAAAAAATCwAAEwsA' +
              'AAAAAAAAAAAAAAAA/w==',
          type: 'image/bmp',
        };
        var mockFile2 = {
          body: 'Qk06AAAAAAAAADYAAAAoAAAAAQAAAP////8BACAAAAAAAAAAAAATCwAAEwsA' +
              'AAAAAAAAAAAA/////w==',
          type: 'image/bmp'
        };
        var mockCommit = {
          commit: '9a1a1d10baece5efbba10bc4ccf808a67a50ac0a',
          parents: [{
            commit: '7338aa9adfe57909f1fdaf88975cdea467d3382f',
            subject: 'Added a carrot',
          }],
          author: {
            name: 'Wyatt Allen',
            email: 'wyatta@google.com',
            date: '2016-05-23 21:44:51.000000000',
            tz: -420,
          },
          committer: {
            name: 'Wyatt Allen',
            email: 'wyatta@google.com',
            date: '2016-05-25 00:25:41.000000000',
            tz: -420,
          },
          subject: 'Updated the carrot',
          message: 'Updated the carrot\n\nChange-Id: Iabcd123\n',
        };
        var mockComments = {baseComments: [], comments: []};

        var stubs = [];
        stubs.push(sandbox.stub(element, '_getDiff',
            function() { return Promise.resolve(mockDiff); }));
        stubs.push(sandbox.stub(element.$.restAPI, 'getCommitInfo',
            function() { return Promise.resolve(mockCommit); }));
        stubs.push(sandbox.stub(element.$.restAPI,
            'getCommitFileContents',
            function() { return Promise.resolve(mockFile1); }));
        stubs.push(sandbox.stub(element.$.restAPI,
            'getChangeFileContents',
            function() { return Promise.resolve(mockFile2); }));
        stubs.push(sandbox.stub(element.$.restAPI, '_getDiffComments',
            function() { return Promise.resolve(mockComments); }));
        stubs.push(sandbox.stub(element.$.restAPI, 'getDiffDrafts',
            function() { return Promise.resolve(mockComments); }));

        element.patchRange = {basePatchNum: 'PARENT', patchNum: 1};

        var rendered = function() {
          // Recognizes that it should be an image diff.
          assert.isTrue(element.isImageDiff);
          assert.instanceOf(element.$.diffBuilder._builder, GrDiffBuilderImage);

          // Left image rendered with the parent commit's version of the file.
          var leftInmage = element.$.diffTable.querySelector('td.left img');
          assert.isOk(leftInmage);
          assert.equal(leftInmage.getAttribute('src'),
              'data:image/bmp;base64, ' + mockFile1.body);

          // Right image rendered with this change's revision of the image.
          var rightInmage = element.$.diffTable.querySelector('td.right img');
          assert.isOk(rightInmage);
          assert.equal(rightInmage.getAttribute('src'),
              'data:image/bmp;base64, ' + mockFile2.body);

          // Cleanup.
          element.removeEventListener('render', rendered);

          done();
        };

        element.addEventListener('render', rendered);

        element.$.restAPI.getDiffPreferences().then(function(prefs) {
          element.prefs = prefs;
          element.reload();
        });
      });

      test('_handleTap lineNum', function(done) {
        var addDraftStub = sinon.stub(element, 'addDraftAtLine');
        var el = document.createElement('div');
        el.className = 'lineNum';
        el.addEventListener('click', function(e) {
          element._handleTap(e);
          assert.isTrue(addDraftStub.called);
          assert.equal(addDraftStub.lastCall.args[0], el);
          done();
        });
        el.click();
      });

      test('_handleTap context', function(done) {
        var showContextStub = sinon.stub(element.$.diffBuilder, 'showContext');
        var el = document.createElement('div');
        el.className = 'showContext';
        el.addEventListener('click', function(e) {
          element._handleTap(e);
          assert.isTrue(showContextStub.called);
          done();
        });
        el.click();
      });

      test('_handleTap content', function(done) {
        var content = document.createElement('div');
        var lineEl = document.createElement('div');

        var selectStub = sandbox.stub(element, '_selectLine');
        var getLineStub = sandbox.stub(element.$.diffBuilder,
            'getLineElByChild', function() { return lineEl; });

        content.className = 'content';
        content.addEventListener('click', function(e) {
          element._handleTap(e);
          assert.isTrue(selectStub.called);
          assert.equal(selectStub.lastCall.args[0], lineEl);
          done();
        });
        content.click();
      });

      test('_getDiff handles null diff responses', function(done) {
        stub('gr-rest-api-interface', {
          getDiff: function() { return Promise.resolve(null); },
        });
        element.changeNum = 123;
        element.patchRange = {basePatchNum: 1, patchNum: 2};
        element.path = 'file.txt';
        element._getDiff().then(done);
      });
    });

    suite('logged in', function() {
      setup(function() {
        stub('gr-rest-api-interface', {
          getLoggedIn: function() { return Promise.resolve(true); },
          getPreferences: function() {
            return Promise.resolve({time_format: 'HHMM_12'});
          },
        });
        element = fixture('basic');
      });

      test('get drafts', function(done) {
        element.patchRange = {basePatchNum: 0, patchNum: 0};
        var draftsResponse = {
          baseComments: [{id: 'foo'}],
          comments: [{id: 'bar'}],
        };
        var getDraftsStub = sandbox.stub(element.$.restAPI, 'getDiffDrafts',
            function() { return Promise.resolve(draftsResponse); });
        element._getDiffDrafts().then(function(result) {
          assert.deepEqual(result, draftsResponse);
          done();
        });
      });

      test('get comments and drafts', function(done) {
        var comments = {
          baseComments: [
            {id: 'bc1', __commentSide: 'left'},
            {id: 'bc2', __commentSide: 'left'},
          ],
          comments: [
            {id: 'c1', __commentSide: 'right'},
            {id: 'c2', __commentSide: 'right'},
          ],
        };
        var diffCommentsStub = sandbox.stub(element, '_getDiffComments',
            function() { return Promise.resolve(comments); });

        var drafts = {
          baseComments: [
            {id: 'bd1', __commentSide: 'left'},
            {id: 'bd2', __commentSide: 'left'},
          ],
          comments: [
            {id: 'd1', __commentSide: 'right'},
            {id: 'd2', __commentSide: 'right'},
          ],
        };

        var diffDraftsStub = sandbox.stub(element, '_getDiffDrafts',
            function() { return Promise.resolve(drafts); });

        var robotComments = {
          baseComments: [
            {id: 'br1', __commentSide: 'left'},
            {id: 'br2', __commentSide: 'left'},
          ],
          comments: [
            {id: 'r1', __commentSide: 'right'},
            {id: 'r2', __commentSide: 'right'},
          ],
        };

        var diffRobotCommentStub = sandbox.stub(element,
            '_getDiffRobotComments', function() {
          return Promise.resolve(robotComments); });

        element.changeNum = '42';
        element.patchRange = {
          basePatchNum: 'PARENT',
          patchNum: 3,
        };
        element.path = '/path/to/foo';
        element.projectConfig = {foo: 'bar'};

        element._getDiffCommentsAndDrafts().then(function(result) {
          assert.deepEqual(result, {
            meta: {
              changeNum: '42',
              patchRange: {
                basePatchNum: 'PARENT',
                patchNum: 3,
              },
              path: '/path/to/foo',
              projectConfig: {foo: 'bar'},
            },
            left: [
              {id: 'bc1', __commentSide: 'left'},
              {id: 'bc2', __commentSide: 'left'},
              {id: 'bd1', __draft: true, __commentSide: 'left'},
              {id: 'bd2', __draft: true, __commentSide: 'left'},
              {id: 'br1', __commentSide: 'left'},
              {id: 'br2', __commentSide: 'left'},
            ],
            right: [
              {id: 'c1', __commentSide: 'right'},
              {id: 'c2', __commentSide: 'right'},
              {id: 'd1', __draft: true, __commentSide: 'right'},
              {id: 'd2', __draft: true, __commentSide: 'right'},
              {id: 'r1', __commentSide: 'right'},
              {id: 'r2', __commentSide: 'right'},
            ],
          });

          done();
        });
      });

      suite('handle comment-update', function() {

        setup(function() {
          element._comments = {
            meta: {
              changeNum: '42',
              patchRange: {
                basePatchNum: 'PARENT',
                patchNum: 3,
              },
              path: '/path/to/foo',
              projectConfig: {foo: 'bar'},
            },
            left: [
              {id: 'bc1', side: 'PARENT', __commentSide: 'left'},
              {id: 'bc2', side: 'PARENT', __commentSide: 'left'},
              {id: 'bd1', __draft: true, side: 'PARENT', __commentSide: 'left'},
              {id: 'bd2', __draft: true, side: 'PARENT', __commentSide: 'left'},
            ],
            right: [
              {id: 'c1', __commentSide: 'right'},
              {id: 'c2', __commentSide: 'right'},
              {id: 'd1', __draft: true, __commentSide: 'right'},
              {id: 'd2', __draft: true, __commentSide: 'right'},
            ],
          };
        });

        test('creating a draft', function() {
          var comment = {__draft: true, __draftID: 'tempID', side: 'PARENT',
              __commentSide: 'left'};
          element.fire('comment-update', {comment: comment});
          assert.include(element._comments.left, comment);
        });

        test('saving a draft', function() {
          var draftID = 'tempID';
          var id = 'savedID';
          element._comments.left.push(
              {__draft: true, __draftID: draftID, side: 'PARENT',
              __commentSide: 'left'});
          element.fire('comment-update', {comment:
              {id: id, __draft: true, __draftID: draftID, side: 'PARENT',
              __commentSide: 'left'},
          });
          var drafts = element._comments.left.filter(function(item) {
            return item.__draftID === draftID;
          });
          assert.equal(drafts.length, 1);
          assert.equal(drafts[0].id, id);
        });
      });
    });
  });
</script>
-												Diff view refactor/cleanup

This breaks gr-diff-view into three components:

+ gr-diff-view: manages keyboard shortcuts and fetching
  change information.
+ gr-diff: fetches diff, comment, and draft data. Normalizes
  it for use in rendering via gr-diff-side.
+ gr-diff-side: renders the normalized model constructed in
  gr-diff.

Comments are not implemented using the new model for the
sake of the reviewer's sanity.

Feature: Issue 3648
Feature: Issue 3663

Change-Id: I60b8a61ef4349d0b7e45b105bb704aa1c07cd358

											
										
										
											2015-12-11 12:02:57 -05:00
+								<!DOCTYPE html>
 								<!--
 								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.
 								-->
 								<meta name="viewport" content="width=device-width, minimum-scale=1.0, initial-scale=1.0, user-scalable=yes">
 								<title>gr-diff</title>
-												Refactor directory structure of components

There is no change in functionality. Only moving things around.

+ Separate html from the js.
+ Place the unit test for a component within the same folder.
+ Organize the components in subfolders.

Change-Id: I51fdc510db75fc1b33f040ca63decbbdfd4d5513

											
										
										
											2016-03-04 17:48:22 -05:00
+								<script src="../../../bower_components/webcomponentsjs/webcomponents.min.js"></script>
 								<script src="../../../bower_components/web-component-tester/browser.js"></script>
-												Add support for images in diffs

If gr-diff recognizes that the file difference it's representing is
between images, it uses a different diff-builder that displays images
in a side-by-side-manner. In this case gr-diff will also make requests
for the image data itself, which it can pass down into the image-based
diff-builder.

Adds methods to gr-rest-api-interface to support rendering the data
relevant to image diffs. For images that are revisions of the current
change, provides "getChangeFileContents". For images that come from the
parent tree (i.e. if the basePatchNum is "PARENT") the interface
provides "getCommitInfo" to determine the SHA of the parent commit, and
"getCommitFileContents" which can get file contents for a given commit.

Bug: Issue 3822
Change-Id: I9be025b4e549fca97c87cdbeede6cb64dea5eac0

											
										
										
											2016-05-23 17:18:43 -07:00
+								<script src="../../../scripts/util.js"></script>
-												Diff view refactor/cleanup

This breaks gr-diff-view into three components:

+ gr-diff-view: manages keyboard shortcuts and fetching
  change information.
+ gr-diff: fetches diff, comment, and draft data. Normalizes
  it for use in rendering via gr-diff-side.
+ gr-diff-side: renders the normalized model constructed in
  gr-diff.

Comments are not implemented using the new model for the
sake of the reviewer's sanity.

Feature: Issue 3648
Feature: Issue 3663

Change-Id: I60b8a61ef4349d0b7e45b105bb704aa1c07cd358

											
										
										
											2015-12-11 12:02:57 -05:00
-												Refactor directory structure of components

There is no change in functionality. Only moving things around.

+ Separate html from the js.
+ Place the unit test for a component within the same folder.
+ Organize the components in subfolders.

Change-Id: I51fdc510db75fc1b33f040ca63decbbdfd4d5513

											
										
										
											2016-03-04 17:48:22 -05:00
+								<link rel="import" href="../../../bower_components/iron-test-helpers/iron-test-helpers.html">
 								<link rel="import" href="gr-diff.html">
-												Diff view refactor/cleanup

This breaks gr-diff-view into three components:

+ gr-diff-view: manages keyboard shortcuts and fetching
  change information.
+ gr-diff: fetches diff, comment, and draft data. Normalizes
  it for use in rendering via gr-diff-side.
+ gr-diff-side: renders the normalized model constructed in
  gr-diff.

Comments are not implemented using the new model for the
sake of the reviewer's sanity.

Feature: Issue 3648
Feature: Issue 3663

Change-Id: I60b8a61ef4349d0b7e45b105bb704aa1c07cd358

											
										
										
											2015-12-11 12:02:57 -05:00
 								<test-fixture id="basic">
 								  <template>
-												Fix issue where navigating between files was causing double requests

Because _diffOptionsChanged fired whenever any of the parameters
passed into them changed, it was firing twice when _paramsChanged
was called in gr-diff-view during a keyboard shortcut event to
change files. Switch to a single `reload` function.

Also add a loading indicator when a diff is loading.

Change-Id: I4fbed3ff1bf4e1fc723a7a0abc726ab8b8bc89d6

											
										
										
											2016-01-11 20:43:02 -05:00
+								    <gr-diff></gr-diff>
-												Diff view refactor/cleanup

This breaks gr-diff-view into three components:

+ gr-diff-view: manages keyboard shortcuts and fetching
  change information.
+ gr-diff: fetches diff, comment, and draft data. Normalizes
  it for use in rendering via gr-diff-side.
+ gr-diff-side: renders the normalized model constructed in
  gr-diff.

Comments are not implemented using the new model for the
sake of the reviewer's sanity.

Feature: Issue 3648
Feature: Issue 3663

Change-Id: I60b8a61ef4349d0b7e45b105bb704aa1c07cd358

											
										
										
											2015-12-11 12:02:57 -05:00
+								  </template>
 								</test-fixture>
 								<script>
 								  suite('gr-diff tests', function() {
 								    var element;
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								    var sandbox;
 								    setup(function() {
 								      sandbox = sinon.sandbox.create();
 								    });
 								    teardown(function() {
 								      sandbox.restore();
 								    });
-												Diff view refactor/cleanup

This breaks gr-diff-view into three components:

+ gr-diff-view: manages keyboard shortcuts and fetching
  change information.
+ gr-diff: fetches diff, comment, and draft data. Normalizes
  it for use in rendering via gr-diff-side.
+ gr-diff-side: renders the normalized model constructed in
  gr-diff.

Comments are not implemented using the new model for the
sake of the reviewer's sanity.

Feature: Issue 3648
Feature: Issue 3663

Change-Id: I60b8a61ef4349d0b7e45b105bb704aa1c07cd358

											
										
										
											2015-12-11 12:02:57 -05:00
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								    suite('not logged in', function() {
 								      setup(function() {
 								        stub('gr-rest-api-interface', {
 								          getLoggedIn: function() { return Promise.resolve(false); },
 								        });
 								        element = fixture('basic');
-												Move gr-diff-new to gr-diff

Change-Id: Ifaad016f806c31f3df43143b3238b757faa18b20

											
										
										
											2016-03-25 16:48:13 -04:00
+								      });
-												Diff view refactor/cleanup

This breaks gr-diff-view into three components:

+ gr-diff-view: manages keyboard shortcuts and fetching
  change information.
+ gr-diff: fetches diff, comment, and draft data. Normalizes
  it for use in rendering via gr-diff-side.
+ gr-diff-side: renders the normalized model constructed in
  gr-diff.

Comments are not implemented using the new model for the
sake of the reviewer's sanity.

Feature: Issue 3648
Feature: Issue 3663

Change-Id: I60b8a61ef4349d0b7e45b105bb704aa1c07cd358

											
										
										
											2015-12-11 12:02:57 -05:00
-												Toggle left diff on Shift+A

Feature: Issue 3926
Change-Id: Ia52334f2aefeae4b3f115e5779da3b61af25ba11

											
										
										
											2016-08-10 11:53:12 -07:00
+								      test('toggleLeftDiff', function() {
 								        element.toggleLeftDiff();
 								        assert.isTrue(element.classList.contains('no-left'));
 								        element.toggleLeftDiff();
 								        assert.isFalse(element.classList.contains('no-left'));
 								      });
-												Cleanup test format

Change-Id: I8606412953d507b877a67c816d3e7a059265cc77

											
										
										
											2016-11-07 13:19:47 -08:00
+								      test('view does not start with displayLine classList', function() {
-												Make line marker more distinguished

Previously, the line marker was only subtly visible by the highlighted
line number. This change adds a bottom border to the selected line if
the user is using keycodes (j, k, up, down) to more the cursor. When
the escape key is pressed, the distinguished line marker will dissapear.

Feature: Issue 4739
Change-Id: If8c751efc137ef87cfdad1c8bf7d905de1219107

											
										
										
											2016-11-02 16:25:53 -07:00
+								        assert.isFalse(
 								            element.$$('.diffContainer').classList.contains('displayLine'));
 								      });
 								      test('displayLine class added called when displayLine is true',
 								          function() {
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								        var spy = sandbox.spy(element, '_computeContainerClass');
-												Make line marker more distinguished

Previously, the line marker was only subtly visible by the highlighted
line number. This change adds a bottom border to the selected line if
the user is using keycodes (j, k, up, down) to more the cursor. When
the escape key is pressed, the distinguished line marker will dissapear.

Feature: Issue 4739
Change-Id: If8c751efc137ef87cfdad1c8bf7d905de1219107

											
										
										
											2016-11-02 16:25:53 -07:00
+								        element.displayLine = true;
 								        assert.isTrue(spy.called);
 								        assert.isTrue(
 								            element.$$('.diffContainer').classList.contains('displayLine'));
 								      });
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								      test('get drafts', function(done) {
 								        element.patchRange = {basePatchNum: 0, patchNum: 0};
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								        var getDraftsStub = sandbox.stub(element.$.restAPI, 'getDiffDrafts');
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								        element._getDiffDrafts().then(function(result) {
 								          assert.deepEqual(result, {baseComments: [], comments: []});
 								          sinon.assert.notCalled(getDraftsStub);
 								          done();
 								        });
-												Remove 'element#async' usages in tests

Tests which are using 'element#async' are wonky in Safari.
'flush' is also the documented way of testing dom manipulations.

Change-Id: I3ea99c7c80c952fa1c15bbd6289690e57bf8414b

											
										
										
											2016-03-06 14:57:02 +01:00
+								      });
-												Implement comment display/draft authoring

Some additional cleanup of event names and fixing of the bubbles
property not being placed in the right place.

TODO in a follow-up change:
+ Comments are not considered in context, yet. So if there is a
  comment made in a span of common lines that are hidden, it will
  be there underneath the context control but wont show the code.

Feature: Issue 3649
Change-Id: I8117b243a7d8d529e0c1cea155a4b6b436c0c768

											
										
										
											2015-12-20 19:13:45 -05:00
-												Add robot comments to PolyGerrit

This change adds an API request to get robot comments for displaying
inline in the diff view. They are styled in a different color, contain
build and robotId information, and a "please fix" action rather than the
standard set of actions.

Feature: Issue 5089
Change-Id: I1f5954a2ed01920bb7c3dc897e3285687ff7d3ca

											
										
										
											2016-12-07 13:36:49 -08:00
+								      test('get robot comments', function(done) {
 								        element.patchRange = {basePatchNum: 0, patchNum: 0};
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								        var getDraftsStub = sandbox.stub(element.$.restAPI,
-												Add robot comments to PolyGerrit

This change adds an API request to get robot comments for displaying
inline in the diff view. They are styled in a different color, contain
build and robotId information, and a "please fix" action rather than the
standard set of actions.

Feature: Issue 5089
Change-Id: I1f5954a2ed01920bb7c3dc897e3285687ff7d3ca

											
										
										
											2016-12-07 13:36:49 -08:00
+								            'getDiffRobotComments');
 								        element._getDiffDrafts().then(function(result) {
 								          assert.deepEqual(result, {baseComments: [], comments: []});
 								          sinon.assert.notCalled(getDraftsStub);
 								          done();
 								        });
 								      });
-												Show file weblinks (e.g. gitles) in diff view

Bug: Issue 4205
Change-Id: Ib5c832bb29453aa51ebe73732c7b8e6885e7e12f

											
										
										
											2016-08-03 13:16:36 -07:00
+								      test('loads files weblinks', function(done) {
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								        var diffStub = sandbox.stub(element.$.restAPI, 'getDiff').returns(
-												Show file weblinks (e.g. gitles) in diff view

Bug: Issue 4205
Change-Id: Ib5c832bb29453aa51ebe73732c7b8e6885e7e12f

											
										
										
											2016-08-03 13:16:36 -07:00
+								            Promise.resolve({
 								              meta_a: {
 								                web_links: 'foo',
 								              },
 								              meta_b: {
 								                web_links: 'bar',
 								              },
 								            }));
 								        element.patchRange = {};
 								        element._getDiff().then(function() {
 								          assert.deepEqual(element.filesWeblinks, {
 								            meta_a: 'foo',
 								            meta_b: 'bar',
 								          });
 								          done();
 								        });
 								      });
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								      test('remove comment', function() {
 								        element._comments = {
-												Move gr-diff-new to gr-diff

Change-Id: Ifaad016f806c31f3df43143b3238b757faa18b20

											
										
										
											2016-03-25 16:48:13 -04:00
+								          meta: {
 								            changeNum: '42',
 								            patchRange: {
 								              basePatchNum: 'PARENT',
 								              patchNum: 3,
 								            },
 								            path: '/path/to/foo',
 								            projectConfig: {foo: 'bar'},
 								          },
 								          left: [
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								            {id: 'bc1', side: 'PARENT', __commentSide: 'left'},
 								            {id: 'bc2', side: 'PARENT', __commentSide: 'left'},
 								            {id: 'bd1', __draft: true, side: 'PARENT', __commentSide: 'left'},
 								            {id: 'bd2', __draft: true, side: 'PARENT', __commentSide: 'left'},
-												Move gr-diff-new to gr-diff

Change-Id: Ifaad016f806c31f3df43143b3238b757faa18b20

											
										
										
											2016-03-25 16:48:13 -04:00
+								          ],
 								          right: [
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								            {id: 'c1', __commentSide: 'right'},
 								            {id: 'c2', __commentSide: 'right'},
 								            {id: 'd1', __draft: true, __commentSide: 'right'},
 								            {id: 'd2', __draft: true, __commentSide: 'right'},
-												Move gr-diff-new to gr-diff

Change-Id: Ifaad016f806c31f3df43143b3238b757faa18b20

											
										
										
											2016-03-25 16:48:13 -04:00
+								          ],
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								        };
-												Persist diff context length on server

This code will eventually live within a diff preference pane
once options other than context are supported.

Change-Id: I3c752a18d163a55cb3398c0a46544593b0a9faed

											
										
										
											2016-01-06 10:43:30 -05:00
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								        element._removeComment({});
 								        // Using JSON.stringify because Safari 9.1 (11601.5.17.1) doesn’t seem
 								        // to believe that one object deepEquals another even when they do :-/.
 								        assert.equal(JSON.stringify(element._comments), JSON.stringify({
 								          meta: {
 								            changeNum: '42',
 								            patchRange: {
 								              basePatchNum: 'PARENT',
 								              patchNum: 3,
 								            },
 								            path: '/path/to/foo',
 								            projectConfig: {foo: 'bar'},
 								          },
 								          left: [
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								            {id: 'bc1', side: 'PARENT', __commentSide: 'left'},
 								            {id: 'bc2', side: 'PARENT', __commentSide: 'left'},
 								            {id: 'bd1', __draft: true, side: 'PARENT', __commentSide: 'left'},
 								            {id: 'bd2', __draft: true, side: 'PARENT', __commentSide: 'left'},
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          ],
 								          right: [
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								            {id: 'c1', __commentSide: 'right'},
 								            {id: 'c2', __commentSide: 'right'},
 								            {id: 'd1', __draft: true, __commentSide: 'right'},
 								            {id: 'd2', __draft: true, __commentSide: 'right'},
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          ],
 								        }));
-												Account for tab width when wrapping in diff view

This change takes the tab width from the users’ prefs (or the default
value) and accounts for it when wrapping lines in diffs. Previously it
was counting tabs as only one character.

Some small cleanup of dead test code in gr-diff-test.html as well.

Bug: Issue 3756
Change-Id: I560fcc530638d3aeee28723d4abab5ec3993fa8f

											
										
										
											2016-01-19 16:55:47 -05:00
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								        element._removeComment({id: 'bc2', side: 'PARENT',
 								            __commentSide: 'left'});
 								        assert.deepEqual(element._comments, {
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          meta: {
 								            changeNum: '42',
 								            patchRange: {
 								              basePatchNum: 'PARENT',
 								              patchNum: 3,
 								            },
 								            path: '/path/to/foo',
 								            projectConfig: {foo: 'bar'},
-												Move gr-diff-new to gr-diff

Change-Id: Ifaad016f806c31f3df43143b3238b757faa18b20

											
										
										
											2016-03-25 16:48:13 -04:00
+								          },
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          left: [
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								            {id: 'bc1', side: 'PARENT', __commentSide: 'left'},
 								            {id: 'bd1', __draft: true, side: 'PARENT', __commentSide: 'left'},
 								            {id: 'bd2', __draft: true, side: 'PARENT', __commentSide: 'left'},
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          ],
 								          right: [
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								            {id: 'c1', __commentSide: 'right'},
 								            {id: 'c2', __commentSide: 'right'},
 								            {id: 'd1', __draft: true, __commentSide: 'right'},
 								            {id: 'd2', __draft: true, __commentSide: 'right'},
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          ],
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								        });
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								        element._removeComment({id: 'd2', __commentSide: 'right'});
 								        assert.deepEqual(element._comments, {
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          meta: {
 								            changeNum: '42',
 								            patchRange: {
 								              basePatchNum: 'PARENT',
 								              patchNum: 3,
 								            },
 								            path: '/path/to/foo',
 								            projectConfig: {foo: 'bar'},
-												Move gr-diff-new to gr-diff

Change-Id: Ifaad016f806c31f3df43143b3238b757faa18b20

											
										
										
											2016-03-25 16:48:13 -04:00
+								          },
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          left: [
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								            {id: 'bc1', side: 'PARENT', __commentSide: 'left'},
 								            {id: 'bd1', __draft: true, side: 'PARENT', __commentSide: 'left'},
 								            {id: 'bd2', __draft: true, side: 'PARENT', __commentSide: 'left'},
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          ],
 								          right: [
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								            {id: 'c1', __commentSide: 'right'},
 								            {id: 'c2', __commentSide: 'right'},
 								            {id: 'd1', __draft: true, __commentSide: 'right'},
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          ],
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								        });
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								      });
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								      test('thread groups', function() {
 								        var contentEl = document.createElement('div');
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								        var rangeToCheck = 'line-left';
 								        var commentSide = 'left';
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								        var patchNum = 1;
 								        var side = 'PARENT';
 								        var range = {
 								          startLine: 1,
 								          startChar: 1,
 								          endLine: 1,
 								          endChar: 2,
 								        };
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								        element.changeNum = 123;
 								        element.patchRange = {basePatchNum: 1, patchNum: 2};
 								        element.path = 'file.txt';
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								        sandbox.stub(element.$.diffBuilder, 'createCommentThreadGroup',
 								            function() {
 								          return document.createElement('gr-diff-comment-thread-group');
 								        });
 								        // No thread groups.
 								        assert.isNotOk(element._getThreadGroupForLine(contentEl));
 								        // A thread group gets created.
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								        assert.isOk(element._getOrCreateThreadAtLineRange(contentEl, patchNum,
 								            commentSide, side));
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
 								        // Try to fetch a thread with a different range.
 								        range = {
 								          startLine: 1,
 								          startChar: 1,
 								          endLine: 1,
 								          endChar: 3,
 								        };
 								        assert.isOk(element._getOrCreateThreadAtLineRange(
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								            contentEl, patchNum, commentSide, side, range));
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								        // The new thread group can be fetched.
 								        assert.isOk(element._getThreadGroupForLine(contentEl));
 								        assert.equal(contentEl.querySelectorAll(
 								            'gr-diff-comment-thread-group').length, 1);
 								        var threadGroup = contentEl.querySelector(
 								            'gr-diff-comment-thread-group');
 								        var threadLength = Polymer.dom(threadGroup.root).
 								              querySelectorAll('gr-diff-comment-thread').length;
 								        assert.equal(threadLength, 2);
 								      });
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								      test('renders image diffs', function(done) {
 								        var mockDiff = {
 								          meta_a: {name: 'carrot.jpg', content_type: 'image/jpeg', lines: 66},
 								          meta_b: {name: 'carrot.jpg', content_type: 'image/jpeg', lines: 560},
 								          intraline_status: 'OK',
 								          change_type: 'MODIFIED',
 								          diff_header: [
 								            'diff --git a/carrot.jpg b/carrot.jpg',
 								            'index 2adc47d..f9c2f2c 100644',
 								            '--- a/carrot.jpg',
 								            '+++ b/carrot.jpg',
 								            'Binary files differ',
 								          ],
 								          content: [{skip: 66}],
 								          binary: true,
 								        };
 								        var mockFile1 = {
 								          body: 'Qk06AAAAAAAAADYAAAAoAAAAAQAAAP////8BACAAAAAAAAAAAAATCwAAEwsA' +
 								              'AAAAAAAAAAAAAAAA/w==',
 								          type: 'image/bmp',
 								        };
 								        var mockFile2 = {
 								          body: 'Qk06AAAAAAAAADYAAAAoAAAAAQAAAP////8BACAAAAAAAAAAAAATCwAAEwsA' +
 								              'AAAAAAAAAAAA/////w==',
 								          type: 'image/bmp'
 								        };
 								        var mockCommit = {
 								          commit: '9a1a1d10baece5efbba10bc4ccf808a67a50ac0a',
 								          parents: [{
 								            commit: '7338aa9adfe57909f1fdaf88975cdea467d3382f',
 								            subject: 'Added a carrot',
 								          }],
 								          author: {
 								            name: 'Wyatt Allen',
 								            email: 'wyatta@google.com',
 								            date: '2016-05-23 21:44:51.000000000',
 								            tz: -420,
-												Move gr-diff-new to gr-diff

Change-Id: Ifaad016f806c31f3df43143b3238b757faa18b20

											
										
										
											2016-03-25 16:48:13 -04:00
+								          },
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          committer: {
 								            name: 'Wyatt Allen',
 								            email: 'wyatta@google.com',
 								            date: '2016-05-25 00:25:41.000000000',
 								            tz: -420,
-												Move gr-diff-new to gr-diff

Change-Id: Ifaad016f806c31f3df43143b3238b757faa18b20

											
										
										
											2016-03-25 16:48:13 -04:00
+								          },
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          subject: 'Updated the carrot',
 								          message: 'Updated the carrot\n\nChange-Id: Iabcd123\n',
 								        };
 								        var mockComments = {baseComments: [], comments: []};
 								        var stubs = [];
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								        stubs.push(sandbox.stub(element, '_getDiff',
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								            function() { return Promise.resolve(mockDiff); }));
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								        stubs.push(sandbox.stub(element.$.restAPI, 'getCommitInfo',
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								            function() { return Promise.resolve(mockCommit); }));
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								        stubs.push(sandbox.stub(element.$.restAPI,
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								            'getCommitFileContents',
 								            function() { return Promise.resolve(mockFile1); }));
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								        stubs.push(sandbox.stub(element.$.restAPI,
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								            'getChangeFileContents',
 								            function() { return Promise.resolve(mockFile2); }));
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								        stubs.push(sandbox.stub(element.$.restAPI, '_getDiffComments',
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								            function() { return Promise.resolve(mockComments); }));
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								        stubs.push(sandbox.stub(element.$.restAPI, 'getDiffDrafts',
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								            function() { return Promise.resolve(mockComments); }));
 								        element.patchRange = {basePatchNum: 'PARENT', patchNum: 1};
 								        var rendered = function() {
 								          // Recognizes that it should be an image diff.
 								          assert.isTrue(element.isImageDiff);
-												Make gr-builder a Polymer component

Updated tests, fixed draft comments, context expanding.

Change-Id: Ic4bd9682c63edd8e80fbc2abcb4fa5e406a202ab

											
										
										
											2016-06-01 11:41:47 -07:00
+								          assert.instanceOf(element.$.diffBuilder._builder, GrDiffBuilderImage);
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
 								          // Left image rendered with the parent commit's version of the file.
 								          var leftInmage = element.$.diffTable.querySelector('td.left img');
 								          assert.isOk(leftInmage);
 								          assert.equal(leftInmage.getAttribute('src'),
 								              'data:image/bmp;base64, ' + mockFile1.body);
 								          // Right image rendered with this change's revision of the image.
 								          var rightInmage = element.$.diffTable.querySelector('td.right img');
 								          assert.isOk(rightInmage);
 								          assert.equal(rightInmage.getAttribute('src'),
 								              'data:image/bmp;base64, ' + mockFile2.body);
 								          // Cleanup.
 								          element.removeEventListener('render', rendered);
 								          done();
 								        };
 								        element.addEventListener('render', rendered);
 								        element.$.restAPI.getDiffPreferences().then(function(prefs) {
 								          element.prefs = prefs;
 								          element.reload();
 								        });
 								      });
-												Move the diff cursor when the diff content is tapped

When a user taps a line number in a diff, the cursor is moved to that
line and that side of the diff. However, if the user taps the text
content of a diff, the cursor was not moved. With this change, the
cursor is moved to the appropriate line and side of a diff when either
is tapped.

Bug: Issue 4215
Change-Id: I47d24f678f487eb3f8173ea5572865a589d845e4

											
										
										
											2016-06-21 12:43:25 -07:00
 								      test('_handleTap lineNum', function(done) {
 								        var addDraftStub = sinon.stub(element, 'addDraftAtLine');
 								        var el = document.createElement('div');
 								        el.className = 'lineNum';
 								        el.addEventListener('click', function(e) {
 								          element._handleTap(e);
 								          assert.isTrue(addDraftStub.called);
 								          assert.equal(addDraftStub.lastCall.args[0], el);
 								          done();
 								        });
 								        el.click();
 								      });
 								      test('_handleTap context', function(done) {
 								        var showContextStub = sinon.stub(element.$.diffBuilder, 'showContext');
 								        var el = document.createElement('div');
 								        el.className = 'showContext';
 								        el.addEventListener('click', function(e) {
 								          element._handleTap(e);
 								          assert.isTrue(showContextStub.called);
 								          done();
 								        });
 								        el.click();
 								      });
 								      test('_handleTap content', function(done) {
 								        var content = document.createElement('div');
 								        var lineEl = document.createElement('div');
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								        var selectStub = sandbox.stub(element, '_selectLine');
 								        var getLineStub = sandbox.stub(element.$.diffBuilder,
 								            'getLineElByChild', function() { return lineEl; });
-												Move the diff cursor when the diff content is tapped

When a user taps a line number in a diff, the cursor is moved to that
line and that side of the diff. However, if the user taps the text
content of a diff, the cursor was not moved. With this change, the
cursor is moved to the appropriate line and side of a diff when either
is tapped.

Bug: Issue 4215
Change-Id: I47d24f678f487eb3f8173ea5572865a589d845e4

											
										
										
											2016-06-21 12:43:25 -07:00
 								        content.className = 'content';
 								        content.addEventListener('click', function(e) {
 								          element._handleTap(e);
 								          assert.isTrue(selectStub.called);
 								          assert.equal(selectStub.lastCall.args[0], lineEl);
 								          done();
 								        });
 								        content.click();
 								      });
-												Gracefully handle HTTP 409 for diff API

If a file is too large for the server to deliver the diff, the API will
respond with HTTP 409. PolyGerrit interprets th this as a network error
and covers the entire page with an error message. Furthermore, the
handler for loading the diff is not written for this kind of failure and
tries to dereference the diff object -- null in that case.

With this change, the 409 message does not block use of the whole page
and the handler does not break when the diff is null.

Issue: Bug 4770
Change-Id: I68fe50c474fc03d4217e969649f62df38ca5b632

											
										
										
											2016-10-13 11:40:27 -07:00
 								      test('_getDiff handles null diff responses', function(done) {
 								        stub('gr-rest-api-interface', {
 								          getDiff: function() { return Promise.resolve(null); },
 								        });
 								        element.changeNum = 123;
 								        element.patchRange = {basePatchNum: 1, patchNum: 2};
 								        element.path = 'file.txt';
 								        element._getDiff().then(done);
 								      });
-												Fix bug where code with comments outside context wasn't appearing

Also speed up rendering probably unnoticeably via changing a
delete call to a null assignment.
(https://jsperf.com/delete-vs-undefined-vs-null/3).

Bug: Issue 3755
Change-Id: I9d91cbcb00f045ba622a103b44b3d0f06c3eca9d

											
										
										
											2016-01-21 12:54:05 -05:00
+								    });
-												Add support for images in diffs

If gr-diff recognizes that the file difference it's representing is
between images, it uses a different diff-builder that displays images
in a side-by-side-manner. In this case gr-diff will also make requests
for the image data itself, which it can pass down into the image-based
diff-builder.

Adds methods to gr-rest-api-interface to support rendering the data
relevant to image diffs. For images that are revisions of the current
change, provides "getChangeFileContents". For images that come from the
parent tree (i.e. if the basePatchNum is "PARENT") the interface
provides "getCommitInfo" to determine the SHA of the parent commit, and
"getCommitFileContents" which can get file contents for a given commit.

Bug: Issue 3822
Change-Id: I9be025b4e549fca97c87cdbeede6cb64dea5eac0

											
										
										
											2016-05-23 17:18:43 -07:00
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								    suite('logged in', function() {
 								      setup(function() {
 								        stub('gr-rest-api-interface', {
 								          getLoggedIn: function() { return Promise.resolve(true); },
-												First round cleanup of network requests & errors from tests

+ These were slowing down tests in cases where it would actually hit a
  live server, potentially adding the latency from the network to the
  test.
+ Other fixes involve removing unused imports of util.js amongst other
  small tweaks/fixes.

Bug: Issue 4016
Change-Id: I442deefebeffc6a701e4922faccfe1c74b3a35b6

											
										
										
											2016-10-15 20:22:00 -07:00
+								          getPreferences: function() {
 								            return Promise.resolve({time_format: 'HHMM_12'});
 								          },
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								        });
 								        element = fixture('basic');
 								      });
 								      test('get drafts', function(done) {
 								        element.patchRange = {basePatchNum: 0, patchNum: 0};
 								        var draftsResponse = {
 								          baseComments: [{id: 'foo'}],
 								          comments: [{id: 'bar'}],
 								        };
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								        var getDraftsStub = sandbox.stub(element.$.restAPI, 'getDiffDrafts',
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								            function() { return Promise.resolve(draftsResponse); });
 								        element._getDiffDrafts().then(function(result) {
 								          assert.deepEqual(result, draftsResponse);
 								          done();
 								        });
 								      });
 								      test('get comments and drafts', function(done) {
 								        var comments = {
 								          baseComments: [
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								            {id: 'bc1', __commentSide: 'left'},
 								            {id: 'bc2', __commentSide: 'left'},
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          ],
 								          comments: [
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								            {id: 'c1', __commentSide: 'right'},
 								            {id: 'c2', __commentSide: 'right'},
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          ],
 								        };
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								        var diffCommentsStub = sandbox.stub(element, '_getDiffComments',
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								            function() { return Promise.resolve(comments); });
 								        var drafts = {
 								          baseComments: [
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								            {id: 'bd1', __commentSide: 'left'},
 								            {id: 'bd2', __commentSide: 'left'},
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          ],
 								          comments: [
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								            {id: 'd1', __commentSide: 'right'},
 								            {id: 'd2', __commentSide: 'right'},
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          ],
 								        };
-												Add robot comments to PolyGerrit

This change adds an API request to get robot comments for displaying
inline in the diff view. They are styled in a different color, contain
build and robotId information, and a "please fix" action rather than the
standard set of actions.

Feature: Issue 5089
Change-Id: I1f5954a2ed01920bb7c3dc897e3285687ff7d3ca

											
										
										
											2016-12-07 13:36:49 -08:00
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								        var diffDraftsStub = sandbox.stub(element, '_getDiffDrafts',
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								            function() { return Promise.resolve(drafts); });
-												Add robot comments to PolyGerrit

This change adds an API request to get robot comments for displaying
inline in the diff view. They are styled in a different color, contain
build and robotId information, and a "please fix" action rather than the
standard set of actions.

Feature: Issue 5089
Change-Id: I1f5954a2ed01920bb7c3dc897e3285687ff7d3ca

											
										
										
											2016-12-07 13:36:49 -08:00
+								        var robotComments = {
 								          baseComments: [
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								            {id: 'br1', __commentSide: 'left'},
 								            {id: 'br2', __commentSide: 'left'},
-												Add robot comments to PolyGerrit

This change adds an API request to get robot comments for displaying
inline in the diff view. They are styled in a different color, contain
build and robotId information, and a "please fix" action rather than the
standard set of actions.

Feature: Issue 5089
Change-Id: I1f5954a2ed01920bb7c3dc897e3285687ff7d3ca

											
										
										
											2016-12-07 13:36:49 -08:00
+								          ],
 								          comments: [
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								            {id: 'r1', __commentSide: 'right'},
 								            {id: 'r2', __commentSide: 'right'},
-												Add robot comments to PolyGerrit

This change adds an API request to get robot comments for displaying
inline in the diff view. They are styled in a different color, contain
build and robotId information, and a "please fix" action rather than the
standard set of actions.

Feature: Issue 5089
Change-Id: I1f5954a2ed01920bb7c3dc897e3285687ff7d3ca

											
										
										
											2016-12-07 13:36:49 -08:00
+								          ],
 								        };
-												Allow multiple threads per line, with different ranges

- Add concept of diff comment thread groups, which are all of the
  threads at a particular line number.

- The thread group is responsible for breaking up comments into threads
  based on the range of the comment.

- Thread groups are ordered by the updated time of the first comment in
  the group.

- Thread groups are given a key, based on comment range, which is used
  to determine what thread group a new comment should go in (or if it
  needs a new one).

Feature: Issue 5292
Change-Id: If544e8bb879262de3ce5397e86124837b66ada04

											
										
										
											2017-01-27 15:33:08 -08:00
+								        var diffRobotCommentStub = sandbox.stub(element,
 								            '_getDiffRobotComments', function() {
 								          return Promise.resolve(robotComments); });
-												Add robot comments to PolyGerrit

This change adds an API request to get robot comments for displaying
inline in the diff view. They are styled in a different color, contain
build and robotId information, and a "please fix" action rather than the
standard set of actions.

Feature: Issue 5089
Change-Id: I1f5954a2ed01920bb7c3dc897e3285687ff7d3ca

											
										
										
											2016-12-07 13:36:49 -08:00
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								        element.changeNum = '42';
 								        element.patchRange = {
 								          basePatchNum: 'PARENT',
 								          patchNum: 3,
 								        };
 								        element.path = '/path/to/foo';
 								        element.projectConfig = {foo: 'bar'};
 								        element._getDiffCommentsAndDrafts().then(function(result) {
 								          assert.deepEqual(result, {
 								            meta: {
 								              changeNum: '42',
 								              patchRange: {
 								                basePatchNum: 'PARENT',
 								                patchNum: 3,
 								              },
 								              path: '/path/to/foo',
 								              projectConfig: {foo: 'bar'},
 								            },
 								            left: [
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								              {id: 'bc1', __commentSide: 'left'},
 								              {id: 'bc2', __commentSide: 'left'},
 								              {id: 'bd1', __draft: true, __commentSide: 'left'},
 								              {id: 'bd2', __draft: true, __commentSide: 'left'},
 								              {id: 'br1', __commentSide: 'left'},
 								              {id: 'br2', __commentSide: 'left'},
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								            ],
 								            right: [
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								              {id: 'c1', __commentSide: 'right'},
 								              {id: 'c2', __commentSide: 'right'},
 								              {id: 'd1', __draft: true, __commentSide: 'right'},
 								              {id: 'd2', __draft: true, __commentSide: 'right'},
 								              {id: 'r1', __commentSide: 'right'},
 								              {id: 'r2', __commentSide: 'right'},
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								            ],
 								          });
 								          done();
 								        });
 								      });
 								      suite('handle comment-update', function() {
 								        setup(function() {
 								          element._comments = {
 								            meta: {
 								              changeNum: '42',
 								              patchRange: {
 								                basePatchNum: 'PARENT',
 								                patchNum: 3,
 								              },
 								              path: '/path/to/foo',
 								              projectConfig: {foo: 'bar'},
 								            },
 								            left: [
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								              {id: 'bc1', side: 'PARENT', __commentSide: 'left'},
 								              {id: 'bc2', side: 'PARENT', __commentSide: 'left'},
 								              {id: 'bd1', __draft: true, side: 'PARENT', __commentSide: 'left'},
 								              {id: 'bd2', __draft: true, side: 'PARENT', __commentSide: 'left'},
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								            ],
 								            right: [
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								              {id: 'c1', __commentSide: 'right'},
 								              {id: 'c2', __commentSide: 'right'},
 								              {id: 'd1', __draft: true, __commentSide: 'right'},
 								              {id: 'd2', __draft: true, __commentSide: 'right'},
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								            ],
 								          };
 								        });
 								        test('creating a draft', function() {
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								          var comment = {__draft: true, __draftID: 'tempID', side: 'PARENT',
 								              __commentSide: 'left'};
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          element.fire('comment-update', {comment: comment});
 								          assert.include(element._comments.left, comment);
 								        });
 								        test('saving a draft', function() {
 								          var draftID = 'tempID';
 								          var id = 'savedID';
 								          element._comments.left.push(
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								              {__draft: true, __draftID: draftID, side: 'PARENT',
 								              __commentSide: 'left'});
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          element.fire('comment-update', {comment:
-												Don't merge threads on same line left/right

Goes along with c/95273/. Adds commentSide attribute to comments to see
which side of the diff view they belong on. This is also used as part
of the locationRange for the gr-diff-comment-thread-group, so that two
thread groups can be on the same line or range for the unified group (
one for the right, one for the left).

Note: there is already a 'side' attribute on the gr-diff-comment, which
is confusing. This side actually references 'PARENT' or 'REVISION', to
identify whether the comment belongs to the parent or any revision. On
diffs where two revisions are compared to each other, this cannot be
used to determine left/right. However, because 'side' is part of
the CommentInfo entity[1], it is difficult to change the name and make
more sense out of that.

[1] https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#comment-info

Bug: Issue 5114
Change-Id: I5cc4c17d4bb134e31e5cc07ff9b08ed349488c97

											
										
										
											2017-01-30 12:03:13 -08:00
+								              {id: id, __draft: true, __draftID: draftID, side: 'PARENT',
 								              __commentSide: 'left'},
-												Gr-diff retrofit: store comment state

Fixing UI data pipe line, re-rendering:
 - side, draft text and editing status in UI comment objects
 - update gr-diff UI model on comment save/update

Feature: Issue 3910
Change-Id: I96f714c7de9add6e316dcf64bb7d566690b9d3ae

											
										
										
											2016-05-23 15:24:05 -07:00
+								          });
 								          var drafts = element._comments.left.filter(function(item) {
 								            return item.__draftID === draftID;
 								          });
 								          assert.equal(drafts.length, 1);
 								          assert.equal(drafts[0].id, id);
 								        });
-												Add support for images in diffs

If gr-diff recognizes that the file difference it's representing is
between images, it uses a different diff-builder that displays images
in a side-by-side-manner. In this case gr-diff will also make requests
for the image data itself, which it can pass down into the image-based
diff-builder.

Adds methods to gr-rest-api-interface to support rendering the data
relevant to image diffs. For images that are revisions of the current
change, provides "getChangeFileContents". For images that come from the
parent tree (i.e. if the basePatchNum is "PARENT") the interface
provides "getCommitInfo" to determine the SHA of the parent commit, and
"getCommitFileContents" which can get file contents for a given commit.

Bug: Issue 3822
Change-Id: I9be025b4e549fca97c87cdbeede6cb64dea5eac0

											
										
										
											2016-05-23 17:18:43 -07:00
+								      });
 								    });
-												Persist diff context length on server

This code will eventually live within a diff preference pane
once options other than context are supported.

Change-Id: I3c752a18d163a55cb3398c0a46544593b0a9faed

											
										
										
											2016-01-06 10:43:30 -05:00
+								  });
-												Diff view refactor/cleanup

This breaks gr-diff-view into three components:

+ gr-diff-view: manages keyboard shortcuts and fetching
  change information.
+ gr-diff: fetches diff, comment, and draft data. Normalizes
  it for use in rendering via gr-diff-side.
+ gr-diff-side: renders the normalized model constructed in
  gr-diff.

Comments are not implemented using the new model for the
sake of the reviewer's sanity.

Feature: Issue 3648
Feature: Issue 3663

Change-Id: I60b8a61ef4349d0b7e45b105bb704aa1c07cd358

											
										
										
											2015-12-11 12:02:57 -05:00
+								</script>