gerrit/polygerrit-ui/app/elements/diff/gr-diff-comment/gr-diff-comment_test.html

<!DOCTYPE html>
<!--
@license
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-comment</title>

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

<link rel="import" href="gr-diff-comment.html">

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

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

<test-fixture id="draft">
  <template>
    <gr-diff-comment draft="true"></gr-diff-comment>
  </template>
</test-fixture>

<script>

  function isVisible(el) {
    assert.ok(el);
    return getComputedStyle(el).getPropertyValue('display') !== 'none';
  }

  suite('gr-diff-comment tests', () => {
    let element;
    let sandbox;
    setup(() => {
      stub('gr-rest-api-interface', {
        getAccount() { return Promise.resolve(null); },
      });
      element = fixture('basic');
      element.comment = {
        author: {
          name: 'Mr. Peanutbutter',
          email: 'tenn1sballchaser@aol.com',
        },
        id: 'baf0414d_60047215',
        line: 5,
        message: 'is this a crossover episode!?',
        updated: '2015-12-08 19:48:33.843000000',
      };
      sandbox = sinon.sandbox.create();
    });

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

    test('collapsible comments', () => {
      // When a comment (not draft) is loaded, it should be collapsed
      assert.isTrue(element.collapsed);
      assert.isFalse(isVisible(element.$$('gr-formatted-text')),
          'gr-formatted-text is not visible');
      assert.isFalse(isVisible(element.$$('.actions')),
          'actions are not visible');
      assert.isNotOk(element.textarea, 'textarea is not visible');

      // The header middle content is only visible when comments are collapsed.
      // It shows the message in a condensed way, and limits to a single line.
      assert.isTrue(isVisible(element.$$('.collapsedContent')),
          'header middle content is visible');

      // When the header row is clicked, the comment should expand
      MockInteractions.tap(element.$.header);
      assert.isFalse(element.collapsed);
      assert.isTrue(isVisible(element.$$('gr-formatted-text')),
          'gr-formatted-text is visible');
      assert.isTrue(isVisible(element.$$('.actions')),
          'actions are visible');
      assert.isNotOk(element.textarea, 'textarea is not visible');
      assert.isFalse(isVisible(element.$$('.collapsedContent')),
          'header middle content is not visible');
    });

    test('clicking on date link does not trigger nav', () => {
      const showStub = sinon.stub(page, 'show');
      const dateEl = element.$$('.date');
      assert.ok(dateEl);
      MockInteractions.tap(dateEl);
      const dest = window.location.pathname + '#5';
      assert(showStub.lastCall.calledWithExactly(dest, null, false),
          'Should navigate to ' + dest + ' without triggering nav');
      showStub.restore();
    });

    test('message is not retrieved from storage when other edits', done => {
      const storageStub = sandbox.stub(element.$.storage, 'getDraftComment');
      const loadSpy = sandbox.spy(element, '_loadLocalDraft');

      element.changeNum = 1;
      element.patchNum = 1;
      element.comment = {
        author: {
          name: 'Mr. Peanutbutter',
          email: 'tenn1sballchaser@aol.com',
        },
        line: 5,
        __otherEditing: true,
      };
      flush(() => {
        assert.isTrue(loadSpy.called);
        assert.isFalse(storageStub.called);
        done();
      });
    });

    test('message is retrieved from storage when no other edits', done => {
      const storageStub = sandbox.stub(element.$.storage, 'getDraftComment');
      const loadSpy = sandbox.spy(element, '_loadLocalDraft');

      element.changeNum = 1;
      element.patchNum = 1;
      element.comment = {
        author: {
          name: 'Mr. Peanutbutter',
          email: 'tenn1sballchaser@aol.com',
        },
        line: 5,
      };
      flush(() => {
        assert.isTrue(loadSpy.called);
        assert.isTrue(storageStub.called);
        done();
      });
    });

    test('_getPatchNum', () => {
      element.side = 'PARENT';
      element.patchNum = 1;
      assert.equal(element._getPatchNum(), 'PARENT');
      element.side = 'REVISION';
      assert.equal(element._getPatchNum(), 1);
    });

    test('comment expand and collapse', () => {
      element.collapsed = true;
      assert.isFalse(isVisible(element.$$('gr-formatted-text')),
          'gr-formatted-text is not visible');
      assert.isFalse(isVisible(element.$$('.actions')),
          'actions are not visible');
      assert.isNotOk(element.textarea, 'textarea is not visible');
      assert.isTrue(isVisible(element.$$('.collapsedContent')),
          'header middle content is visible');

      element.collapsed = false;
      assert.isFalse(element.collapsed);
      assert.isTrue(isVisible(element.$$('gr-formatted-text')),
          'gr-formatted-text is visible');
      assert.isTrue(isVisible(element.$$('.actions')),
          'actions are visible');
      assert.isNotOk(element.textarea, 'textarea is not visible');
      assert.isFalse(isVisible(element.$$('.collapsedContent')),
          'header middle content is is not visible');
    });

    suite('while editing', () => {
      setup(() => {
        element.editing = true;
        element._messageText = 'test';
        sandbox.stub(element, '_handleCancel');
        sandbox.stub(element, '_handleSave');
        flushAsynchronousOperations();
      });

      suite('when text is empty', () => {
        setup(() => {
          element._messageText = '';
          element.comment = {};
        });

        test('esc closes comment when text is empty', () => {
          MockInteractions.pressAndReleaseKeyOn(
              element.textarea, 27); // esc
          assert.isTrue(element._handleCancel.called);
        });

        test('ctrl+enter does not save', () => {
          MockInteractions.pressAndReleaseKeyOn(
              element.textarea, 13, 'ctrl'); // ctrl + enter
          assert.isFalse(element._handleSave.called);
        });

        test('meta+enter does not save', () => {
          MockInteractions.pressAndReleaseKeyOn(
              element.textarea, 13, 'meta'); // meta + enter
          assert.isFalse(element._handleSave.called);
        });

        test('ctrl+s does not save', () => {
          MockInteractions.pressAndReleaseKeyOn(
              element.textarea, 83, 'ctrl'); // ctrl + s
          assert.isFalse(element._handleSave.called);
        });
      });

      test('esc does not close comment that has content', () => {
        MockInteractions.pressAndReleaseKeyOn(
            element.textarea, 27); // esc
        assert.isFalse(element._handleCancel.called);
      });

      test('ctrl+enter saves', () => {
        MockInteractions.pressAndReleaseKeyOn(
            element.textarea, 13, 'ctrl'); // ctrl + enter
        assert.isTrue(element._handleSave.called);
      });

      test('meta+enter saves', () => {
        MockInteractions.pressAndReleaseKeyOn(
            element.textarea, 13, 'meta'); // meta + enter
        assert.isTrue(element._handleSave.called);
      });

      test('ctrl+s saves', () => {
        MockInteractions.pressAndReleaseKeyOn(
            element.textarea, 83, 'ctrl'); // ctrl + s
        assert.isTrue(element._handleSave.called);
      });
    });
    test('delete comment button for non-admins is hidden', () => {
      element._isAdmin = false;
      assert.isFalse(element.$$('.action.delete')
          .classList.contains('showDeleteButtons'));
    });

    test('delete comment button for admins with draft is hidden', () => {
      element._isAdmin = false;
      element.draft = true;
      assert.isFalse(element.$$('.action.delete')
          .classList.contains('showDeleteButtons'));
    });

    test('delete comment', done => {
      sandbox.stub(
          element.$.restAPI, 'deleteComment').returns(Promise.resolve({}));
      sandbox.spy(element.confirmDeleteOverlay, 'open');
      element.changeNum = 42;
      element.patchNum = 0xDEADBEEF;
      element._isAdmin = true;
      assert.isTrue(element.$$('.action.delete')
          .classList.contains('showDeleteButtons'));
      MockInteractions.tap(element.$$('.action.delete'));
      flush(() => {
        element.confirmDeleteOverlay.open.lastCall.returnValue.then(() => {
          const dialog =
              this.confirmDeleteOverlay.querySelector('#confirmDeleteComment');
          dialog.message = 'removal reason';
          element._handleConfirmDeleteComment();
          assert.isTrue(element.$.restAPI.deleteComment.calledWith(
              42, 0xDEADBEEF, 'baf0414d_60047215', 'removal reason'));
          done();
        });
      });
    });

    suite('draft update reporting', () => {
      let endStub;
      let getTimerStub;
      let mockEvent;

      setup(() => {
        mockEvent = {preventDefault() {}};
        sandbox.stub(element, 'save')
            .returns(Promise.resolve({}));
        sandbox.stub(element, '_discardDraft')
            .returns(Promise.resolve({}));
        endStub = sinon.stub();
        getTimerStub = sandbox.stub(element.$.reporting, 'getTimer')
            .returns({end: endStub});
      });

      test('create', () => {
        element.comment = {};
        return element._handleSave(mockEvent).then(() => {
          assert.isTrue(endStub.calledOnce);
          assert.isTrue(getTimerStub.calledOnce);
          assert.equal(getTimerStub.lastCall.args[0], 'CreateDraftComment');
        });
      });

      test('update', () => {
        element.comment = {id: 'abc_123'};
        return element._handleSave(mockEvent).then(() => {
          assert.isTrue(endStub.calledOnce);
          assert.isTrue(getTimerStub.calledOnce);
          assert.equal(getTimerStub.lastCall.args[0], 'UpdateDraftComment');
        });
      });

      test('discard', () => {
        element.comment = {id: 'abc_123'};
        sandbox.stub(element, '_closeConfirmDiscardOverlay');
        return element._handleConfirmDiscard(mockEvent).then(() => {
          assert.isTrue(endStub.calledOnce);
          assert.isTrue(getTimerStub.calledOnce);
          assert.equal(getTimerStub.lastCall.args[0], 'DiscardDraftComment');
        });
      });
    });

    test('edit reports interaction', () => {
      const reportStub = sandbox.stub(element.$.reporting,
          'recordDraftInteraction');
      MockInteractions.tap(element.$$('.edit'));
      assert.isTrue(reportStub.calledOnce);
    });

    test('discard reports interaction', () => {
      const reportStub = sandbox.stub(element.$.reporting,
          'recordDraftInteraction');
      element.draft = true;
      MockInteractions.tap(element.$$('.discard'));
      assert.isTrue(reportStub.calledOnce);
    });
  });

  suite('gr-diff-comment draft tests', () => {
    let element;
    let sandbox;

    setup(() => {
      stub('gr-rest-api-interface', {
        getAccount() { return Promise.resolve(null); },
        saveDiffDraft() {
          return Promise.resolve({
            ok: true,
            text() {
              return Promise.resolve(
                  ')]}\'\n{' +
                  '"id": "baf0414d_40572e03",' +
                  '"path": "/path/to/file",' +
                  '"line": 5,' +
                  '"updated": "2015-12-08 21:52:36.177000000",' +
                  '"message": "saved!"' +
                '}'
              );
            },
          });
        },
        removeChangeReviewer() {
          return Promise.resolve({ok: true});
        },
      });
      stub('gr-storage', {
        getDraftComment() { return null; },
      });
      element = fixture('draft');
      element.changeNum = 42;
      element.patchNum = 1;
      element.editing = false;
      element.comment = {
        __commentSide: 'right',
        __draft: true,
        __draftID: 'temp_draft_id',
        path: '/path/to/file',
        line: 5,
      };
      element.commentSide = 'right';
      sandbox = sinon.sandbox.create();
    });

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

    test('button visibility states', () => {
      element.showActions = false;
      assert.isTrue(element.$$('.humanActions').hasAttribute('hidden'));
      assert.isTrue(element.$$('.robotActions').hasAttribute('hidden'));

      element.showActions = true;
      assert.isFalse(element.$$('.humanActions').hasAttribute('hidden'));
      assert.isTrue(element.$$('.robotActions').hasAttribute('hidden'));

      element.draft = true;
      assert.isTrue(isVisible(element.$$('.edit')), 'edit is visible');
      assert.isTrue(isVisible(element.$$('.discard')), 'discard is visible');
      assert.isFalse(isVisible(element.$$('.save')), 'save is not visible');
      assert.isFalse(isVisible(element.$$('.cancel')), 'cancel is not visible');
      assert.isTrue(isVisible(element.$$('.resolve')), 'resolve is visible');
      assert.isFalse(element.$$('.humanActions').hasAttribute('hidden'));
      assert.isTrue(element.$$('.robotActions').hasAttribute('hidden'));

      element.editing = true;
      flushAsynchronousOperations();
      assert.isFalse(isVisible(element.$$('.edit')), 'edit is not visible');
      assert.isFalse(isVisible(element.$$('.discard')), 'discard not visible');
      assert.isTrue(isVisible(element.$$('.save')), 'save is visible');
      assert.isTrue(isVisible(element.$$('.cancel')), 'cancel is visible');
      assert.isTrue(isVisible(element.$$('.resolve')), 'resolve is visible');
      assert.isFalse(element.$$('.humanActions').hasAttribute('hidden'));
      assert.isTrue(element.$$('.robotActions').hasAttribute('hidden'));

      element.draft = false;
      element.editing = false;
      flushAsynchronousOperations();
      assert.isFalse(isVisible(element.$$('.edit')), 'edit is not visible');
      assert.isFalse(isVisible(element.$$('.discard')),
          'discard is not visible');
      assert.isFalse(isVisible(element.$$('.save')), 'save is not visible');
      assert.isFalse(isVisible(element.$$('.cancel')), 'cancel is not visible');
      assert.isFalse(element.$$('.humanActions').hasAttribute('hidden'));
      assert.isTrue(element.$$('.robotActions').hasAttribute('hidden'));

      element.comment.id = 'foo';
      element.draft = true;
      element.editing = true;
      flushAsynchronousOperations();
      assert.isTrue(isVisible(element.$$('.cancel')), 'cancel is visible');
      assert.isFalse(element.$$('.humanActions').hasAttribute('hidden'));
      assert.isTrue(element.$$('.robotActions').hasAttribute('hidden'));

      element.isRobotComment = true;
      element.draft = true;
      assert.isTrue(element.$$('.humanActions').hasAttribute('hidden'));
      assert.isFalse(element.$$('.robotActions').hasAttribute('hidden'));

      // It is not expected to see Robot comment drafts, but if they appear,
      // they will behave the same as non-drafts.
      element.draft = false;
      assert.isTrue(element.$$('.humanActions').hasAttribute('hidden'));
      assert.isFalse(element.$$('.robotActions').hasAttribute('hidden'));

      // A robot comment with run ID should display plain text.
      element.set(['comment', 'robot_run_id'], 'text');
      element.editing = false;
      element.collapsed = false;
      flushAsynchronousOperations();
      assert.isNotOk(element.$$('.robotRun.link'));
      assert.notEqual(getComputedStyle(element.$$('.robotRun.text')).display,
          'none');

      // A robot comment with run ID and url should display a link.
      element.set(['comment', 'url'], '/path/to/run');
      flushAsynchronousOperations();
      assert.notEqual(getComputedStyle(element.$$('.robotRun.link')).display,
          'none');
      assert.equal(getComputedStyle(element.$$('.robotRun.text')).display,
          'none');
    });

    test('collapsible drafts', () => {
      assert.isTrue(element.collapsed);
      assert.isFalse(isVisible(element.$$('gr-formatted-text')),
          'gr-formatted-text is not visible');
      assert.isFalse(isVisible(element.$$('.actions')),
          'actions are not visible');
      assert.isNotOk(element.textarea, 'textarea is not visible');
      assert.isTrue(isVisible(element.$$('.collapsedContent')),
          'header middle content is visible');

      MockInteractions.tap(element.$.header);
      assert.isFalse(element.collapsed);
      assert.isTrue(isVisible(element.$$('gr-formatted-text')),
          'gr-formatted-text is visible');
      assert.isTrue(isVisible(element.$$('.actions')),
          'actions are visible');
      assert.isNotOk(element.textarea, 'textarea is not visible');
      assert.isFalse(isVisible(element.$$('.collapsedContent')),
          'header middle content is is not visible');

      // When the edit button is pressed, should still see the actions
      // and also textarea
      MockInteractions.tap(element.$$('.edit'));
      flushAsynchronousOperations();
      assert.isFalse(element.collapsed);
      assert.isFalse(isVisible(element.$$('gr-formatted-text')),
          'gr-formatted-text is not visible');
      assert.isTrue(isVisible(element.$$('.actions')),
          'actions are visible');
      assert.isTrue(isVisible(element.textarea), 'textarea is visible');
      assert.isFalse(isVisible(element.$$('.collapsedContent')),
          'header middle content is not visible');

      // When toggle again, everything should be hidden except for textarea
      // and header middle content should be visible
      MockInteractions.tap(element.$.header);
      assert.isTrue(element.collapsed);
      assert.isFalse(isVisible(element.$$('gr-formatted-text')),
          'gr-formatted-text is not visible');
      assert.isFalse(isVisible(element.$$('.actions')),
          'actions are not visible');
      assert.isFalse(isVisible(element.$$('gr-textarea')),
          'textarea is not visible');
      assert.isTrue(isVisible(element.$$('.collapsedContent')),
          'header middle content is visible');

      // When toggle again, textarea should remain open in the state it was
      // before
      MockInteractions.tap(element.$.header);
      assert.isFalse(isVisible(element.$$('gr-formatted-text')),
          'gr-formatted-text is not visible');
      assert.isTrue(isVisible(element.$$('.actions')),
          'actions are visible');
      assert.isTrue(isVisible(element.textarea), 'textarea is visible');
      assert.isFalse(isVisible(element.$$('.collapsedContent')),
          'header middle content is not visible');
    });

    test('draft creation/cancellation', done => {
      assert.isFalse(element.editing);
      MockInteractions.tap(element.$$('.edit'));
      assert.isTrue(element.editing);

      element._messageText = '';
      const eraseMessageDraftSpy = sandbox.spy(element, '_eraseDraftComment');

      // Save should be disabled on an empty message.
      let disabled = element.$$('.save').hasAttribute('disabled');
      assert.isTrue(disabled, 'save button should be disabled.');
      element._messageText = '     ';
      disabled = element.$$('.save').hasAttribute('disabled');
      assert.isTrue(disabled, 'save button should be disabled.');

      const updateStub = sinon.stub();
      element.addEventListener('comment-update', updateStub);

      let numDiscardEvents = 0;
      element.addEventListener('comment-discard', e => {
        numDiscardEvents++;
        assert.isFalse(eraseMessageDraftSpy.called);
        if (numDiscardEvents === 2) {
          assert.isFalse(updateStub.called);
          done();
        }
      });
      MockInteractions.tap(element.$$('.cancel'));
      element.flushDebouncer('fire-update');
      element._messageText = '';
      flushAsynchronousOperations();
      MockInteractions.pressAndReleaseKeyOn(element.textarea, 27); // esc
    });

    test('draft discard removes message from storage', done => {
      element._messageText = '';
      const eraseMessageDraftSpy = sandbox.spy(element, '_eraseDraftComment');
      sandbox.stub(element, '_closeConfirmDiscardOverlay');

      element.addEventListener('comment-discard', e => {
        assert.isTrue(eraseMessageDraftSpy.called);
        done();
      });
      element._handleConfirmDiscard({preventDefault: sinon.stub()});
    });

    test('storage is cleared only after save success', () => {
      element._messageText = 'test';
      const eraseStub = sandbox.stub(element, '_eraseDraftComment');
      sandbox.stub(element.$.restAPI, 'getResponseObject')
          .returns(Promise.resolve({}));

      sandbox.stub(element, '_saveDraft').returns(Promise.resolve({ok: false}));

      const savePromise = element.save();
      assert.isFalse(eraseStub.called);
      return savePromise.then(() => {
        assert.isFalse(eraseStub.called);

        element._saveDraft.restore();
        sandbox.stub(element, '_saveDraft')
            .returns(Promise.resolve({ok: true}));
        return element.save().then(() => {
          assert.isTrue(eraseStub.called);
        });
      });
    });

    test('_computeSaveDisabled', () => {
      const comment = {unresolved: true};
      const msgComment = {message: 'test', unresolved: true};
      assert.equal(element._computeSaveDisabled('', comment, false), true);
      assert.equal(element._computeSaveDisabled('test', comment, false), false);
      assert.equal(element._computeSaveDisabled('', msgComment, false), true);
      assert.equal(
          element._computeSaveDisabled('test', msgComment, false), false);
      assert.equal(
          element._computeSaveDisabled('test2', msgComment, false), false);
      assert.equal(element._computeSaveDisabled('test', comment, true), false);
      assert.equal(element._computeSaveDisabled('', comment, true), true);
      assert.equal(element._computeSaveDisabled('', comment, false), true);
    });

    suite('confirm discard', () => {
      let discardStub;
      let overlayStub;
      let mockEvent;

      setup(() => {
        discardStub = sandbox.stub(element, '_discardDraft');
        overlayStub = sandbox.stub(element, '_openOverlay')
            .returns(Promise.resolve());
        mockEvent = {preventDefault: sinon.stub()};
      });

      test('confirms discard of comments with message text', () => {
        element._messageText = 'test';
        element._handleDiscard(mockEvent);
        assert.isTrue(overlayStub.calledWith(element.confirmDiscardOverlay));
        assert.isFalse(discardStub.called);
      });

      test('no confirmation for comments without message text', () => {
        element._messageText = '';
        element._handleDiscard(mockEvent);
        assert.isFalse(overlayStub.called);
        assert.isTrue(discardStub.calledOnce);
      });
    });

    test('ctrl+s saves comment', done => {
      const stub = sinon.stub(element, 'save', () => {
        assert.isTrue(stub.called);
        stub.restore();
        done();
        return Promise.resolve();
      });
      element._messageText = 'is that the horse from horsing around??';
      element.editing = true;
      flushAsynchronousOperations();
      MockInteractions.pressAndReleaseKeyOn(
          element.textarea.$.textarea.textarea,
          83, 'ctrl'); // 'ctrl + s'
    });

    test('draft saving/editing', done => {
      const fireStub = sinon.stub(element, 'fire');
      const cancelDebounce = sandbox.stub(element, 'cancelDebouncer');

      element.draft = true;
      MockInteractions.tap(element.$$('.edit'));
      element._messageText = 'good news, everyone!';
      element.flushDebouncer('fire-update');
      element.flushDebouncer('store');
      assert(fireStub.calledWith('comment-update'),
          'comment-update should be sent');
      assert.isTrue(fireStub.calledOnce);

      element._messageText = 'good news, everyone!';
      element.flushDebouncer('fire-update');
      element.flushDebouncer('store');
      assert.isTrue(fireStub.calledOnce,
          'No events should fire for text editing');

      MockInteractions.tap(element.$$('.save'));

      assert.isTrue(element.disabled,
          'Element should be disabled when creating draft.');

      element._xhrPromise.then(draft => {
        assert(fireStub.calledWith('comment-save'),
            'comment-save should be sent');
        assert(cancelDebounce.calledWith('store'));

        assert.deepEqual(fireStub.lastCall.args[1], {
          comment: {
            __commentSide: 'right',
            __draft: true,
            __draftID: 'temp_draft_id',
            id: 'baf0414d_40572e03',
            line: 5,
            message: 'saved!',
            path: '/path/to/file',
            updated: '2015-12-08 21:52:36.177000000',
          },
          patchNum: 1,
        });
        assert.isFalse(element.disabled,
            'Element should be enabled when done creating draft.');
        assert.equal(draft.message, 'saved!');
        assert.isFalse(element.editing);
      }).then(() => {
        MockInteractions.tap(element.$$('.edit'));
        element._messageText = 'You’ll be delivering a package to Chapek 9, ' +
            'a world where humans are killed on sight.';
        MockInteractions.tap(element.$$('.save'));
        assert.isTrue(element.disabled,
            'Element should be disabled when updating draft.');

        element._xhrPromise.then(draft => {
          assert.isFalse(element.disabled,
              'Element should be enabled when done updating draft.');
          assert.equal(draft.message, 'saved!');
          assert.isFalse(element.editing);
          fireStub.restore();
          done();
        });
      });
    });

    test('draft prevent save when disabled', () => {
      const saveStub = sandbox.stub(element, 'save').returns(Promise.resolve());
      element.showActions = true;
      element.draft = true;
      MockInteractions.tap(element.$.header);
      MockInteractions.tap(element.$$('.edit'));
      element._messageText = 'good news, everyone!';
      element.flushDebouncer('fire-update');
      element.flushDebouncer('store');

      element.disabled = true;
      MockInteractions.tap(element.$$('.save'));
      assert.isFalse(saveStub.called);

      element.disabled = false;
      MockInteractions.tap(element.$$('.save'));
      assert.isTrue(saveStub.calledOnce);
    });

    test('clicking on date link does not trigger nav', () => {
      const showStub = sinon.stub(page, 'show');
      const dateEl = element.$$('.date');
      assert.ok(dateEl);
      MockInteractions.tap(dateEl);
      const dest = window.location.pathname + '#5';
      assert(showStub.lastCall.calledWithExactly(dest, null, false),
          'Should navigate to ' + dest + ' without triggering nav');
      showStub.restore();
    });

    test('proper event fires on resolve, comment is not saved', done => {
      const save = sandbox.stub(element, 'save');
      element.addEventListener('comment-update', e => {
        assert.isTrue(e.detail.comment.unresolved);
        assert.isFalse(save.called);
        done();
      });
      MockInteractions.tap(element.$$('.resolve input'));
    });

    test('resolved comment state indicated by checkbox', () => {
      sandbox.stub(element, 'save');
      element.comment = {unresolved: false};
      assert.isTrue(element.$$('.resolve input').checked);
      element.comment = {unresolved: true};
      assert.isFalse(element.$$('.resolve input').checked);
    });

    test('resolved checkbox saves with tap when !editing', () => {
      element.editing = false;
      const save = sandbox.stub(element, 'save');

      element.comment = {unresolved: false};
      assert.isTrue(element.$$('.resolve input').checked);
      element.comment = {unresolved: true};
      assert.isFalse(element.$$('.resolve input').checked);
      assert.isFalse(save.called);
      MockInteractions.tap(element.$.resolvedCheckbox);
      assert.isTrue(element.$$('.resolve input').checked);
      assert.isTrue(save.called);
    });

    suite('draft saving messages', () => {
      test('_getSavingMessage', () => {
        assert.equal(element._getSavingMessage(0), 'All changes saved');
        assert.equal(element._getSavingMessage(1), 'Saving 1 draft...');
        assert.equal(element._getSavingMessage(2), 'Saving 2 drafts...');
        assert.equal(element._getSavingMessage(3), 'Saving 3 drafts...');
      });

      test('_show{Start,End}Request', () => {
        const updateStub = sandbox.stub(element, '_updateRequestToast');
        element._numPendingDraftRequests.number = 1;

        element._showStartRequest();
        assert.isTrue(updateStub.calledOnce);
        assert.equal(updateStub.lastCall.args[0], 2);
        assert.equal(element._numPendingDraftRequests.number, 2);

        element._showEndRequest();
        assert.isTrue(updateStub.calledTwice);
        assert.equal(updateStub.lastCall.args[0], 1);
        assert.equal(element._numPendingDraftRequests.number, 1);

        element._showEndRequest();
        assert.isTrue(updateStub.calledThrice);
        assert.equal(updateStub.lastCall.args[0], 0);
        assert.equal(element._numPendingDraftRequests.number, 0);
      });
    });

    test('cancelling an unsaved draft discards, persists in storage', () => {
      const discardSpy = sandbox.spy(element, '_fireDiscard');
      const storeStub = sandbox.stub(element.$.storage, 'setDraftComment');
      const eraseStub = sandbox.stub(element.$.storage, 'eraseDraftComment');
      element._messageText = 'test text';
      flushAsynchronousOperations();
      element.flushDebouncer('store');

      assert.isTrue(storeStub.called);
      assert.equal(storeStub.lastCall.args[1], 'test text');
      element._handleCancel({preventDefault: () => {}});
      assert.isTrue(discardSpy.called);
      assert.isFalse(eraseStub.called);
    });

    test('cancelling edit on a saved draft does not store', () => {
      element.comment.id = 'foo';
      const discardSpy = sandbox.spy(element, '_fireDiscard');
      const storeStub = sandbox.stub(element.$.storage, 'setDraftComment');
      element._messageText = 'test text';
      flushAsynchronousOperations();
      element.flushDebouncer('store');

      assert.isFalse(storeStub.called);
      element._handleCancel({preventDefault: () => {}});
      assert.isTrue(discardSpy.called);
    });

    test('deleting text from saved draft and saving deletes the draft', () => {
      element.comment = {id: 'foo', message: 'test'};
      element._messageText = '';
      const discardStub = sandbox.stub(element, '_discardDraft');

      element.save();
      assert.isTrue(discardStub.called);
    });
  });
</script>
-												[PolyGerrit] Render (read-only) comments and column width ruler.

Also some small additional changes as well:
+ Correct some :host selectors that were causing issues when Shadow DOM
  was used instead of Shady DOM.
+ Two of the same revisions should not be shown in side-by-side view.
  When two are specified via the url as /N..N/ redirect to /N/.
+ Added header to the diff view to give context and allow the user to
  go back to the top-level change.

Feature: Issue 3676
Feature: Issue 3648
Feature: Issue 3649
Change-Id: Ib39bb7cb2eab26740f80971d4e00d579a2e08b0b

											
										
										
											2015-11-18 16:31:18 -05:00
+								<!DOCTYPE html>
 								<!--
-												Add @license tags to PG HTML and JS assets

These tags are preserved by the Closure compiler and vulcanize in order
to serve the license notices embedded in the outputs. In a standalone
Gerrit server, these license are also covered in the LICENSES.txt served
with the documentation. When serving PG assets from a CDN, it's less
obvious what the corresponding LICENSES.txt file is, since the CDN is
not directly linked to a running Gerrit server. Safer to embed the
licenses in the assets themselves.

Change-Id: Id1add1451fad1baa7916882a6bda02c326ccc988

											
										
										
											2018-03-26 10:04:27 -04:00
+								@license
-												[PolyGerrit] Render (read-only) comments and column width ruler.

Also some small additional changes as well:
+ Correct some :host selectors that were causing issues when Shadow DOM
  was used instead of Shady DOM.
+ Two of the same revisions should not be shown in side-by-side view.
  When two are specified via the url as /N..N/ redirect to /N/.
+ Added header to the diff view to give context and allow the user to
  go back to the top-level change.

Feature: Issue 3676
Feature: Issue 3648
Feature: Issue 3649
Change-Id: Ib39bb7cb2eab26740f80971d4e00d579a2e08b0b

											
										
										
											2015-11-18 16:31:18 -05:00
+								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-comment</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-lite.min.js"></script>
 								<script src="../../../bower_components/web-component-tester/browser.js"></script>
-												Add polygerrit-ui/app/test/common-test-setup.html

This is a partial roll-forward of c/106190

This replaces all loads of iron-test-helpers with a load of a file
that wraps it, and adds that file to test files that do not currently
load iron-test-helpers.

A future CL will also install polymer-resin via common-test-helpers.html.

I tested by running

$ WCT_ARGS="-l chrome" ./polygerrit-ui/app/run_test.sh

Change-Id: Ifb3cd2c8db13d724f57e56e7e78045470d103a43

											
										
										
											2017-06-02 13:08:19 -04:00
+								<link rel="import" href="../../../test/common-test-setup.html"/>
-												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/page/page.js"></script>
 								<script src="../../../scripts/util.js"></script>
-												[PolyGerrit] Render (read-only) comments and column width ruler.

Also some small additional changes as well:
+ Correct some :host selectors that were causing issues when Shadow DOM
  was used instead of Shady DOM.
+ Two of the same revisions should not be shown in side-by-side view.
  When two are specified via the url as /N..N/ redirect to /N/.
+ Added header to the diff view to give context and allow the user to
  go back to the top-level change.

Feature: Issue 3676
Feature: Issue 3648
Feature: Issue 3649
Change-Id: Ib39bb7cb2eab26740f80971d4e00d579a2e08b0b

											
										
										
											2015-11-18 16:31:18 -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="gr-diff-comment.html">
-												[PolyGerrit] Render (read-only) comments and column width ruler.

Also some small additional changes as well:
+ Correct some :host selectors that were causing issues when Shadow DOM
  was used instead of Shady DOM.
+ Two of the same revisions should not be shown in side-by-side view.
  When two are specified via the url as /N..N/ redirect to /N/.
+ Added header to the diff view to give context and allow the user to
  go back to the top-level change.

Feature: Issue 3676
Feature: Issue 3648
Feature: Issue 3649
Change-Id: Ib39bb7cb2eab26740f80971d4e00d579a2e08b0b

											
										
										
											2015-11-18 16:31:18 -05:00
-												Collection of prospective test flake fixes

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

Bug: Issue 5792
Change-Id: I9ab6e8e40d9811dd52906335426764c052907609

											
										
										
											2017-03-28 17:02:44 -07:00
+								<script>void(0);</script>
-												[PolyGerrit] Render (read-only) comments and column width ruler.

Also some small additional changes as well:
+ Correct some :host selectors that were causing issues when Shadow DOM
  was used instead of Shady DOM.
+ Two of the same revisions should not be shown in side-by-side view.
  When two are specified via the url as /N..N/ redirect to /N/.
+ Added header to the diff view to give context and allow the user to
  go back to the top-level change.

Feature: Issue 3676
Feature: Issue 3648
Feature: Issue 3649
Change-Id: Ib39bb7cb2eab26740f80971d4e00d579a2e08b0b

											
										
										
											2015-11-18 16:31:18 -05:00
+								<test-fixture id="basic">
 								  <template>
 								    <gr-diff-comment></gr-diff-comment>
 								  </template>
 								</test-fixture>
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								<test-fixture id="draft">
 								  <template>
 								    <gr-diff-comment draft="true"></gr-diff-comment>
 								  </template>
 								</test-fixture>
-												[PolyGerrit] Render (read-only) comments and column width ruler.

Also some small additional changes as well:
+ Correct some :host selectors that were causing issues when Shadow DOM
  was used instead of Shady DOM.
+ Two of the same revisions should not be shown in side-by-side view.
  When two are specified via the url as /N..N/ redirect to /N/.
+ Added header to the diff view to give context and allow the user to
  go back to the top-level change.

Feature: Issue 3676
Feature: Issue 3648
Feature: Issue 3649
Change-Id: Ib39bb7cb2eab26740f80971d4e00d579a2e08b0b

											
										
										
											2015-11-18 16:31:18 -05:00
+								<script>
-												Allow for comments to be collapsible

Previously in Polygerrit, comments were always expanded. You could
always see the full comment (if multiline) and any applicable actions.

This change creates a collapsed comment view.  It adds a preview of the
text to the header row when collapsed, and can be toggled open when any
part of the header is clicked.

Bug: Issue 4698
Change-Id: Idca5caf92eb32518b6737dbb5a3380d227513996

											
										
										
											2016-10-06 10:18:32 -07:00
 								  function isVisible(el) {
 								    assert.ok(el);
 								    return getComputedStyle(el).getPropertyValue('display') !== 'none';
 								  }
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								  suite('gr-diff-comment tests', () => {
 								    let element;
 								    let sandbox;
 								    setup(() => {
-												gr-request/gr-ajax cleanup (gr-diff-comment)

Bug: Issue 3988
Change-Id: I0c100a0b77a256c1eb34f94e8fff0515add5dea1

											
										
										
											2016-05-03 15:14:57 -04:00
+								      stub('gr-rest-api-interface', {
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								        getAccount() { return Promise.resolve(null); },
-												gr-request/gr-ajax cleanup (gr-diff-comment)

Bug: Issue 3988
Change-Id: I0c100a0b77a256c1eb34f94e8fff0515add5dea1

											
										
										
											2016-05-03 15:14:57 -04:00
+								      });
-												[PolyGerrit] Render (read-only) comments and column width ruler.

Also some small additional changes as well:
+ Correct some :host selectors that were causing issues when Shadow DOM
  was used instead of Shady DOM.
+ Two of the same revisions should not be shown in side-by-side view.
  When two are specified via the url as /N..N/ redirect to /N/.
+ Added header to the diff view to give context and allow the user to
  go back to the top-level change.

Feature: Issue 3676
Feature: Issue 3648
Feature: Issue 3649
Change-Id: Ib39bb7cb2eab26740f80971d4e00d579a2e08b0b

											
										
										
											2015-11-18 16:31:18 -05:00
+								      element = fixture('basic');
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								      element.comment = {
 								        author: {
 								          name: 'Mr. Peanutbutter',
 								          email: 'tenn1sballchaser@aol.com',
 								        },
 								        id: 'baf0414d_60047215',
 								        line: 5,
 								        message: 'is this a crossover episode!?',
 								        updated: '2015-12-08 19:48:33.843000000',
-												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
+								      };
-												Escape only closes an empty comment box

Previously, the escape key closed and cancelled any in progress comment.
This was particularly painful for some who were used to a certain text
editor, so now escape only closes an in-progress comment if it's empty.

Bug: Issue 4816
Change-Id: I2749a995ebf914c4387261c387b008f6ce91dd86

											
										
										
											2016-11-02 14:18:48 -07:00
+								      sandbox = sinon.sandbox.create();
 								    });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								    teardown(() => {
-												Escape only closes an empty comment box

Previously, the escape key closed and cancelled any in progress comment.
This was particularly painful for some who were used to a certain text
editor, so now escape only closes an in-progress comment if it's empty.

Bug: Issue 4816
Change-Id: I2749a995ebf914c4387261c387b008f6ce91dd86

											
										
										
											2016-11-02 14:18:48 -07:00
+								      sandbox.restore();
-												[PolyGerrit] Render (read-only) comments and column width ruler.

Also some small additional changes as well:
+ Correct some :host selectors that were causing issues when Shadow DOM
  was used instead of Shady DOM.
+ Two of the same revisions should not be shown in side-by-side view.
  When two are specified via the url as /N..N/ redirect to /N/.
+ Added header to the diff view to give context and allow the user to
  go back to the top-level change.

Feature: Issue 3676
Feature: Issue 3648
Feature: Issue 3649
Change-Id: Ib39bb7cb2eab26740f80971d4e00d579a2e08b0b

											
										
										
											2015-11-18 16:31:18 -05:00
+								    });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								    test('collapsible comments', () => {
-												Allow for comments to be collapsible

Previously in Polygerrit, comments were always expanded. You could
always see the full comment (if multiline) and any applicable actions.

This change creates a collapsed comment view.  It adds a preview of the
text to the header row when collapsed, and can be toggled open when any
part of the header is clicked.

Bug: Issue 4698
Change-Id: Idca5caf92eb32518b6737dbb5a3380d227513996

											
										
										
											2016-10-06 10:18:32 -07:00
+								      // When a comment (not draft) is loaded, it should be collapsed
-												Keyboard shortcuts to expand and collapse all comments

This change adds keyboard shortcuts to the "gr-diff-comment-thread"
expand all comments when 'e' is pressed and collapse all comments when
'shift + e' is pressed. Note that the keyboard event is detected on the
thread instead of the comment to minimize the number of events getting
triggered.

Feature: Issue 4738
Change-Id: Iab77349bd1527d7af5e05a827919a78a86909835

											
										
										
											2016-10-10 17:31:56 -07:00
+								      assert.isTrue(element.collapsed);
-												Wiki-like formatting for PolyGerrit comments

This change is the PolyGerrit counterpart to [1].

Nicer rendering for reviewer comments in PolyGerrit using the Gerrit
Wiki-like format. Whereas, formerly, PG comments were set in PRE blocks
using monospaced font so that the original format and alignment of the
comment can be directly viewed. This change allows comments to default
to a variable-width font with wrapping while separately styling blocks
intended to be pre-formatted text, quotes and lists.

The logic to parse comment text into blocks is borrowed from the Java
implementation found in [1]. Test cases are additionally translated from
this change to ensure coincident behavior.

Introduces GR-FORMATTED-TEXT to display these comments, and which uses a
similar interface to GR-LINKED-TEXT. Much like [1], the comment is
parsed into a list of blocks. These blocks are then mapped to the DOM
nodes that get attached inside the element.

[1] I8e11d363b80bff0b6395f56e210b636f68db36fa

Feature: Issue 4861
Change-Id: I245d6782e2fd8982ac3eda438fe4ca80f3658195

											
										
										
											2016-11-08 15:49:05 -08:00
+								      assert.isFalse(isVisible(element.$$('gr-formatted-text')),
 								          'gr-formatted-text is not visible');
-												Allow for comments to be collapsible

Previously in Polygerrit, comments were always expanded. You could
always see the full comment (if multiline) and any applicable actions.

This change creates a collapsed comment view.  It adds a preview of the
text to the header row when collapsed, and can be toggled open when any
part of the header is clicked.

Bug: Issue 4698
Change-Id: Idca5caf92eb32518b6737dbb5a3380d227513996

											
										
										
											2016-10-06 10:18:32 -07:00
+								      assert.isFalse(isVisible(element.$$('.actions')),
 								          'actions are not visible');
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								      assert.isNotOk(element.textarea, 'textarea is not visible');
-												Allow for comments to be collapsible

Previously in Polygerrit, comments were always expanded. You could
always see the full comment (if multiline) and any applicable actions.

This change creates a collapsed comment view.  It adds a preview of the
text to the header row when collapsed, and can be toggled open when any
part of the header is clicked.

Bug: Issue 4698
Change-Id: Idca5caf92eb32518b6737dbb5a3380d227513996

											
										
										
											2016-10-06 10:18:32 -07:00
 								      // The header middle content is only visible when comments are collapsed.
 								      // It shows the message in a condensed way, and limits to a single line.
 								      assert.isTrue(isVisible(element.$$('.collapsedContent')),
 								          'header middle content is visible');
 								      // When the header row is clicked, the comment should expand
 								      MockInteractions.tap(element.$.header);
-												Keyboard shortcuts to expand and collapse all comments

This change adds keyboard shortcuts to the "gr-diff-comment-thread"
expand all comments when 'e' is pressed and collapse all comments when
'shift + e' is pressed. Note that the keyboard event is detected on the
thread instead of the comment to minimize the number of events getting
triggered.

Feature: Issue 4738
Change-Id: Iab77349bd1527d7af5e05a827919a78a86909835

											
										
										
											2016-10-10 17:31:56 -07:00
+								      assert.isFalse(element.collapsed);
-												Wiki-like formatting for PolyGerrit comments

This change is the PolyGerrit counterpart to [1].

Nicer rendering for reviewer comments in PolyGerrit using the Gerrit
Wiki-like format. Whereas, formerly, PG comments were set in PRE blocks
using monospaced font so that the original format and alignment of the
comment can be directly viewed. This change allows comments to default
to a variable-width font with wrapping while separately styling blocks
intended to be pre-formatted text, quotes and lists.

The logic to parse comment text into blocks is borrowed from the Java
implementation found in [1]. Test cases are additionally translated from
this change to ensure coincident behavior.

Introduces GR-FORMATTED-TEXT to display these comments, and which uses a
similar interface to GR-LINKED-TEXT. Much like [1], the comment is
parsed into a list of blocks. These blocks are then mapped to the DOM
nodes that get attached inside the element.

[1] I8e11d363b80bff0b6395f56e210b636f68db36fa

Feature: Issue 4861
Change-Id: I245d6782e2fd8982ac3eda438fe4ca80f3658195

											
										
										
											2016-11-08 15:49:05 -08:00
+								      assert.isTrue(isVisible(element.$$('gr-formatted-text')),
 								          'gr-formatted-text is visible');
-												Allow for comments to be collapsible

Previously in Polygerrit, comments were always expanded. You could
always see the full comment (if multiline) and any applicable actions.

This change creates a collapsed comment view.  It adds a preview of the
text to the header row when collapsed, and can be toggled open when any
part of the header is clicked.

Bug: Issue 4698
Change-Id: Idca5caf92eb32518b6737dbb5a3380d227513996

											
										
										
											2016-10-06 10:18:32 -07:00
+								      assert.isTrue(isVisible(element.$$('.actions')),
 								          'actions are visible');
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								      assert.isNotOk(element.textarea, 'textarea is not visible');
-												Allow for comments to be collapsible

Previously in Polygerrit, comments were always expanded. You could
always see the full comment (if multiline) and any applicable actions.

This change creates a collapsed comment view.  It adds a preview of the
text to the header row when collapsed, and can be toggled open when any
part of the header is clicked.

Bug: Issue 4698
Change-Id: Idca5caf92eb32518b6737dbb5a3380d227513996

											
										
										
											2016-10-06 10:18:32 -07:00
+								      assert.isFalse(isVisible(element.$$('.collapsedContent')),
 								          'header middle content is not visible');
 								    });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								    test('clicking on date link does not trigger nav', () => {
 								      const showStub = sinon.stub(page, 'show');
 								      const dateEl = element.$$('.date');
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								      assert.ok(dateEl);
 								      MockInteractions.tap(dateEl);
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								      const dest = window.location.pathname + '#5';
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								      assert(showStub.lastCall.calledWithExactly(dest, null, false),
 								          'Should navigate to ' + dest + ' without triggering nav');
 								      showStub.restore();
 								    });
-												Keyboard shortcuts to expand and collapse all comments

This change adds keyboard shortcuts to the "gr-diff-comment-thread"
expand all comments when 'e' is pressed and collapse all comments when
'shift + e' is pressed. Note that the keyboard event is detected on the
thread instead of the comment to minimize the number of events getting
triggered.

Feature: Issue 4738
Change-Id: Iab77349bd1527d7af5e05a827919a78a86909835

											
										
										
											2016-10-10 17:31:56 -07:00
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								    test('message is not retrieved from storage when other edits', done => {
 								      const storageStub = sandbox.stub(element.$.storage, 'getDraftComment');
 								      const loadSpy = sandbox.spy(element, '_loadLocalDraft');
-												Fixes comment issues with multiple editing comments

This change addresses a few issues that existed due to multiple comments
in an editing state at the same time.

1) Fixes issue where if you create two replies and add text to the
second reply, then delete the first one, the text in the second textarea
gets removed.

2) Fixes issue where if you reply and add text, then reply again with
the first draft still editing, the second draft gets populated with the
message from the first comment.

3) Fixes issue where if you have multiple replies and delete one of
them, local storage gets erased. This change sets local storage to the
value of the first editing message found after deleting the other one
(if it exists).

Bug: Issue 4409
Change-Id: Ib5913a34a79783a4a87b4a298e25b02fc587b8dd

											
										
										
											2016-12-22 15:04:11 -08:00
 								      element.changeNum = 1;
 								      element.patchNum = 1;
 								      element.comment = {
 								        author: {
 								          name: 'Mr. Peanutbutter',
 								          email: 'tenn1sballchaser@aol.com',
 								        },
 								        line: 5,
 								        __otherEditing: true,
 								      };
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								      flush(() => {
-												Fixes comment issues with multiple editing comments

This change addresses a few issues that existed due to multiple comments
in an editing state at the same time.

1) Fixes issue where if you create two replies and add text to the
second reply, then delete the first one, the text in the second textarea
gets removed.

2) Fixes issue where if you reply and add text, then reply again with
the first draft still editing, the second draft gets populated with the
message from the first comment.

3) Fixes issue where if you have multiple replies and delete one of
them, local storage gets erased. This change sets local storage to the
value of the first editing message found after deleting the other one
(if it exists).

Bug: Issue 4409
Change-Id: Ib5913a34a79783a4a87b4a298e25b02fc587b8dd

											
										
										
											2016-12-22 15:04:11 -08:00
+								        assert.isTrue(loadSpy.called);
 								        assert.isFalse(storageStub.called);
 								        done();
 								      });
 								    });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								    test('message is retrieved from storage when no other edits', done => {
 								      const storageStub = sandbox.stub(element.$.storage, 'getDraftComment');
 								      const loadSpy = sandbox.spy(element, '_loadLocalDraft');
-												Fixes comment issues with multiple editing comments

This change addresses a few issues that existed due to multiple comments
in an editing state at the same time.

1) Fixes issue where if you create two replies and add text to the
second reply, then delete the first one, the text in the second textarea
gets removed.

2) Fixes issue where if you reply and add text, then reply again with
the first draft still editing, the second draft gets populated with the
message from the first comment.

3) Fixes issue where if you have multiple replies and delete one of
them, local storage gets erased. This change sets local storage to the
value of the first editing message found after deleting the other one
(if it exists).

Bug: Issue 4409
Change-Id: Ib5913a34a79783a4a87b4a298e25b02fc587b8dd

											
										
										
											2016-12-22 15:04:11 -08:00
 								      element.changeNum = 1;
 								      element.patchNum = 1;
 								      element.comment = {
 								        author: {
 								          name: 'Mr. Peanutbutter',
 								          email: 'tenn1sballchaser@aol.com',
 								        },
 								        line: 5,
 								      };
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								      flush(() => {
-												Fixes comment issues with multiple editing comments

This change addresses a few issues that existed due to multiple comments
in an editing state at the same time.

1) Fixes issue where if you create two replies and add text to the
second reply, then delete the first one, the text in the second textarea
gets removed.

2) Fixes issue where if you reply and add text, then reply again with
the first draft still editing, the second draft gets populated with the
message from the first comment.

3) Fixes issue where if you have multiple replies and delete one of
them, local storage gets erased. This change sets local storage to the
value of the first editing message found after deleting the other one
(if it exists).

Bug: Issue 4409
Change-Id: Ib5913a34a79783a4a87b4a298e25b02fc587b8dd

											
										
										
											2016-12-22 15:04:11 -08:00
+								        assert.isTrue(loadSpy.called);
 								        assert.isTrue(storageStub.called);
 								        done();
 								      });
 								    });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								    test('_getPatchNum', () => {
-												Implement isOnParent as functions rather than an attribute on comments

Previously, the rest api interface set '__isOnParent' for comments.
When comments were added, the property from the comment thread
'isOnParent' was passed as a property. When the draft was saved, it was
expecting '__isOnParent' rather than 'isOnParent' and this caused
comments to show up on the wrong side after saved/refreshed, because
'__isOnParent' was undefined.

Instead of changing to either '__isOnParent' which would be strange to
pass as an attribute or 'isOnParent' which would look like it came from
the api directly, this change introduces isOnParent functions so that
translation doesn't need to be done with the API.

Bug: Issue 5831
Change-Id: I3b849ba5878275cda0a39638626a12bd51341a29

											
										
										
											2017-03-21 14:56:19 -07:00
+								      element.side = 'PARENT';
-												Fix local storage with PARENT revision

Previously, if a PARENT revision was getting compared to a patchset,
the local storage key would be the same for both, and there were issues
if a user was trying to write drafts on the same line on either side.

This addresses the issue by storing 'PARENT' as the patch number in the
local storage key, so that each key is unique.

Bug: Issue 5412
Change-Id: Ia8b2f0abe1d24a3849628fe335c931f07bcaff52

											
										
										
											2017-03-13 11:42:42 -07:00
+								      element.patchNum = 1;
 								      assert.equal(element._getPatchNum(), 'PARENT');
-												Implement isOnParent as functions rather than an attribute on comments

Previously, the rest api interface set '__isOnParent' for comments.
When comments were added, the property from the comment thread
'isOnParent' was passed as a property. When the draft was saved, it was
expecting '__isOnParent' rather than 'isOnParent' and this caused
comments to show up on the wrong side after saved/refreshed, because
'__isOnParent' was undefined.

Instead of changing to either '__isOnParent' which would be strange to
pass as an attribute or 'isOnParent' which would look like it came from
the api directly, this change introduces isOnParent functions so that
translation doesn't need to be done with the API.

Bug: Issue 5831
Change-Id: I3b849ba5878275cda0a39638626a12bd51341a29

											
										
										
											2017-03-21 14:56:19 -07:00
+								      element.side = 'REVISION';
-												Fix local storage with PARENT revision

Previously, if a PARENT revision was getting compared to a patchset,
the local storage key would be the same for both, and there were issues
if a user was trying to write drafts on the same line on either side.

This addresses the issue by storing 'PARENT' as the patch number in the
local storage key, so that each key is unique.

Bug: Issue 5412
Change-Id: Ia8b2f0abe1d24a3849628fe335c931f07bcaff52

											
										
										
											2017-03-13 11:42:42 -07:00
+								      assert.equal(element._getPatchNum(), 1);
 								    });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								    test('comment expand and collapse', () => {
-												Keyboard shortcuts to expand and collapse all comments

This change adds keyboard shortcuts to the "gr-diff-comment-thread"
expand all comments when 'e' is pressed and collapse all comments when
'shift + e' is pressed. Note that the keyboard event is detected on the
thread instead of the comment to minimize the number of events getting
triggered.

Feature: Issue 4738
Change-Id: Iab77349bd1527d7af5e05a827919a78a86909835

											
										
										
											2016-10-10 17:31:56 -07:00
+								      element.collapsed = true;
-												Wiki-like formatting for PolyGerrit comments

This change is the PolyGerrit counterpart to [1].

Nicer rendering for reviewer comments in PolyGerrit using the Gerrit
Wiki-like format. Whereas, formerly, PG comments were set in PRE blocks
using monospaced font so that the original format and alignment of the
comment can be directly viewed. This change allows comments to default
to a variable-width font with wrapping while separately styling blocks
intended to be pre-formatted text, quotes and lists.

The logic to parse comment text into blocks is borrowed from the Java
implementation found in [1]. Test cases are additionally translated from
this change to ensure coincident behavior.

Introduces GR-FORMATTED-TEXT to display these comments, and which uses a
similar interface to GR-LINKED-TEXT. Much like [1], the comment is
parsed into a list of blocks. These blocks are then mapped to the DOM
nodes that get attached inside the element.

[1] I8e11d363b80bff0b6395f56e210b636f68db36fa

Feature: Issue 4861
Change-Id: I245d6782e2fd8982ac3eda438fe4ca80f3658195

											
										
										
											2016-11-08 15:49:05 -08:00
+								      assert.isFalse(isVisible(element.$$('gr-formatted-text')),
 								          'gr-formatted-text is not visible');
-												Keyboard shortcuts to expand and collapse all comments

This change adds keyboard shortcuts to the "gr-diff-comment-thread"
expand all comments when 'e' is pressed and collapse all comments when
'shift + e' is pressed. Note that the keyboard event is detected on the
thread instead of the comment to minimize the number of events getting
triggered.

Feature: Issue 4738
Change-Id: Iab77349bd1527d7af5e05a827919a78a86909835

											
										
										
											2016-10-10 17:31:56 -07:00
+								      assert.isFalse(isVisible(element.$$('.actions')),
 								          'actions are not visible');
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								      assert.isNotOk(element.textarea, 'textarea is not visible');
-												Keyboard shortcuts to expand and collapse all comments

This change adds keyboard shortcuts to the "gr-diff-comment-thread"
expand all comments when 'e' is pressed and collapse all comments when
'shift + e' is pressed. Note that the keyboard event is detected on the
thread instead of the comment to minimize the number of events getting
triggered.

Feature: Issue 4738
Change-Id: Iab77349bd1527d7af5e05a827919a78a86909835

											
										
										
											2016-10-10 17:31:56 -07:00
+								      assert.isTrue(isVisible(element.$$('.collapsedContent')),
 								          'header middle content is visible');
 								      element.collapsed = false;
 								      assert.isFalse(element.collapsed);
-												Wiki-like formatting for PolyGerrit comments

This change is the PolyGerrit counterpart to [1].

Nicer rendering for reviewer comments in PolyGerrit using the Gerrit
Wiki-like format. Whereas, formerly, PG comments were set in PRE blocks
using monospaced font so that the original format and alignment of the
comment can be directly viewed. This change allows comments to default
to a variable-width font with wrapping while separately styling blocks
intended to be pre-formatted text, quotes and lists.

The logic to parse comment text into blocks is borrowed from the Java
implementation found in [1]. Test cases are additionally translated from
this change to ensure coincident behavior.

Introduces GR-FORMATTED-TEXT to display these comments, and which uses a
similar interface to GR-LINKED-TEXT. Much like [1], the comment is
parsed into a list of blocks. These blocks are then mapped to the DOM
nodes that get attached inside the element.

[1] I8e11d363b80bff0b6395f56e210b636f68db36fa

Feature: Issue 4861
Change-Id: I245d6782e2fd8982ac3eda438fe4ca80f3658195

											
										
										
											2016-11-08 15:49:05 -08:00
+								      assert.isTrue(isVisible(element.$$('gr-formatted-text')),
 								          'gr-formatted-text is visible');
-												Keyboard shortcuts to expand and collapse all comments

This change adds keyboard shortcuts to the "gr-diff-comment-thread"
expand all comments when 'e' is pressed and collapse all comments when
'shift + e' is pressed. Note that the keyboard event is detected on the
thread instead of the comment to minimize the number of events getting
triggered.

Feature: Issue 4738
Change-Id: Iab77349bd1527d7af5e05a827919a78a86909835

											
										
										
											2016-10-10 17:31:56 -07:00
+								      assert.isTrue(isVisible(element.$$('.actions')),
 								          'actions are visible');
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								      assert.isNotOk(element.textarea, 'textarea is not visible');
-												Keyboard shortcuts to expand and collapse all comments

This change adds keyboard shortcuts to the "gr-diff-comment-thread"
expand all comments when 'e' is pressed and collapse all comments when
'shift + e' is pressed. Note that the keyboard event is detected on the
thread instead of the comment to minimize the number of events getting
triggered.

Feature: Issue 4738
Change-Id: Iab77349bd1527d7af5e05a827919a78a86909835

											
										
										
											2016-10-10 17:31:56 -07:00
+								      assert.isFalse(isVisible(element.$$('.collapsedContent')),
 								          'header middle content is is not visible');
 								    });
-												Escape only closes an empty comment box

Previously, the escape key closed and cancelled any in progress comment.
This was particularly painful for some who were used to a certain text
editor, so now escape only closes an in-progress comment if it's empty.

Bug: Issue 4816
Change-Id: I2749a995ebf914c4387261c387b008f6ce91dd86

											
										
										
											2016-11-02 14:18:48 -07:00
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								    suite('while editing', () => {
 								      setup(() => {
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								        element.editing = true;
 								        element._messageText = 'test';
 								        sandbox.stub(element, '_handleCancel');
 								        sandbox.stub(element, '_handleSave');
 								        flushAsynchronousOperations();
 								      });
-												Escape only closes an empty comment box

Previously, the escape key closed and cancelled any in progress comment.
This was particularly painful for some who were used to a certain text
editor, so now escape only closes an in-progress comment if it's empty.

Bug: Issue 4816
Change-Id: I2749a995ebf914c4387261c387b008f6ce91dd86

											
										
										
											2016-11-02 14:18:48 -07:00
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								      suite('when text is empty', () => {
 								        setup(() => {
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								          element._messageText = '';
-												Delete draft comment when saved with empty text

Recently, the comment editing UX was changed (the discard button was
removed from the editing view). This (obviously) made it impossible to
discard a draft comment whilst editing it.

Editing a comment, clearing the text, and saving now removes the
comment.

Bug: Issue 7832
Change-Id: I0dae814b9ce2e7a5b57530f839c708e59c215341

											
										
										
											2017-11-27 16:13:06 -08:00
+								          element.comment = {};
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								        });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								        test('esc closes comment when text is empty', () => {
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								          MockInteractions.pressAndReleaseKeyOn(
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								              element.textarea, 27); // esc
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								          assert.isTrue(element._handleCancel.called);
 								        });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								        test('ctrl+enter does not save', () => {
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								          MockInteractions.pressAndReleaseKeyOn(
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								              element.textarea, 13, 'ctrl'); // ctrl + enter
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								          assert.isFalse(element._handleSave.called);
 								        });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								        test('meta+enter does not save', () => {
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								          MockInteractions.pressAndReleaseKeyOn(
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								              element.textarea, 13, 'meta'); // meta + enter
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								          assert.isFalse(element._handleSave.called);
 								        });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								        test('ctrl+s does not save', () => {
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								          MockInteractions.pressAndReleaseKeyOn(
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								              element.textarea, 83, 'ctrl'); // ctrl + s
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								          assert.isFalse(element._handleSave.called);
 								        });
 								      });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								      test('esc does not close comment that has content', () => {
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								        MockInteractions.pressAndReleaseKeyOn(
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								            element.textarea, 27); // esc
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								        assert.isFalse(element._handleCancel.called);
 								      });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								      test('ctrl+enter saves', () => {
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								        MockInteractions.pressAndReleaseKeyOn(
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								            element.textarea, 13, 'ctrl'); // ctrl + enter
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								        assert.isTrue(element._handleSave.called);
 								      });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								      test('meta+enter saves', () => {
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								        MockInteractions.pressAndReleaseKeyOn(
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								            element.textarea, 13, 'meta'); // meta + enter
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								        assert.isTrue(element._handleSave.called);
 								      });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								      test('ctrl+s saves', () => {
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								        MockInteractions.pressAndReleaseKeyOn(
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								            element.textarea, 83, 'ctrl'); // ctrl + s
-												Save comments on Ctrl+Enter and Meta+Enter

Feature: Issue 4997
Change-Id: Ia1887b3ee558b96182e3ea987370c9f555c90502

											
										
										
											2017-02-24 16:26:32 -08:00
+								        assert.isTrue(element._handleSave.called);
-												Escape only closes an empty comment box

Previously, the escape key closed and cancelled any in progress comment.
This was particularly painful for some who were used to a certain text
editor, so now escape only closes an in-progress comment if it's empty.

Bug: Issue 4816
Change-Id: I2749a995ebf914c4387261c387b008f6ce91dd86

											
										
										
											2016-11-02 14:18:48 -07:00
+								      });
 								    });
-												Catch-all fix for merged linter errors

Bug: Issue 6179
Change-Id: I436b6dbd88e83b4d901d5446a0c7900678be157d

											
										
										
											2017-05-17 16:00:33 -07:00
+								    test('delete comment button for non-admins is hidden', () => {
-												UI for comments deletion by admins

This change depends on API implemented in Change 105052.

Feature: Issue 4644
Change-Id: I91137aaa69eef419e08c8a568cef9350d8a1448b

											
										
										
											2017-05-08 10:40:06 -07:00
+								      element._isAdmin = false;
-												Fix delete button again

In the previous fix, the function was not called and since it was
the function that set the class to 'hidden' it did not hide.

Change-Id: Ic8f908802cb515086860f20e2c82d0ddd06c0278

											
										
										
											2017-05-18 16:34:17 -07:00
+								      assert.isFalse(element.$$('.action.delete')
 								          .classList.contains('showDeleteButtons'));
-												Do not show delete button for admins when comment is a draft

There was a formatting issue caused by delete buttons in a draft change.
It really does not make sense for the button to be there for drafts
anyway. This change hides the delete button for admins on draft changes.

Bug: Issue 6257
Change-Id: I236eff9db1f0ca76ed658f3048132c9c675ee407

											
										
										
											2017-05-18 13:02:14 -07:00
+								    });
 								    test('delete comment button for admins with draft is hidden', () => {
 								      element._isAdmin = false;
 								      element.draft = true;
-												Fix delete button again

In the previous fix, the function was not called and since it was
the function that set the class to 'hidden' it did not hide.

Change-Id: Ic8f908802cb515086860f20e2c82d0ddd06c0278

											
										
										
											2017-05-18 16:34:17 -07:00
+								      assert.isFalse(element.$$('.action.delete')
 								          .classList.contains('showDeleteButtons'));
-												UI for comments deletion by admins

This change depends on API implemented in Change 105052.

Feature: Issue 4644
Change-Id: I91137aaa69eef419e08c8a568cef9350d8a1448b

											
										
										
											2017-05-08 10:40:06 -07:00
+								    });
-												Catch-all fix for merged linter errors

Bug: Issue 6179
Change-Id: I436b6dbd88e83b4d901d5446a0c7900678be157d

											
										
										
											2017-05-17 16:00:33 -07:00
+								    test('delete comment', done => {
-												UI for comments deletion by admins

This change depends on API implemented in Change 105052.

Feature: Issue 4644
Change-Id: I91137aaa69eef419e08c8a568cef9350d8a1448b

											
										
										
											2017-05-08 10:40:06 -07:00
+								      sandbox.stub(
-												Add gr-autogrow-textarea to gr-diff-comment

This replaces iron-autogrow-textarea so that the diff comments can have
emoji support.

Change-Id: I8bfa31b789604f28aca0ff28dc5c0836afdb6005

											
										
										
											2017-05-03 10:03:35 -07:00
+								          element.$.restAPI, 'deleteComment').returns(Promise.resolve({}));
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								      sandbox.spy(element.confirmDeleteOverlay, 'open');
-												UI for comments deletion by admins

This change depends on API implemented in Change 105052.

Feature: Issue 4644
Change-Id: I91137aaa69eef419e08c8a568cef9350d8a1448b

											
										
										
											2017-05-08 10:40:06 -07:00
+								      element.changeNum = 42;
 								      element.patchNum = 0xDEADBEEF;
 								      element._isAdmin = true;
-												Fix delete button again

In the previous fix, the function was not called and since it was
the function that set the class to 'hidden' it did not hide.

Change-Id: Ic8f908802cb515086860f20e2c82d0ddd06c0278

											
										
										
											2017-05-18 16:34:17 -07:00
+								      assert.isTrue(element.$$('.action.delete')
 								          .classList.contains('showDeleteButtons'));
-												UI for comments deletion by admins

This change depends on API implemented in Change 105052.

Feature: Issue 4644
Change-Id: I91137aaa69eef419e08c8a568cef9350d8a1448b

											
										
										
											2017-05-08 10:40:06 -07:00
+								      MockInteractions.tap(element.$$('.action.delete'));
-												Fix gr-diff-comment_test in Firefox, Safari

Change-Id: I0d11ffa48c254622cbc86ec7c0ce265f24212859

											
										
										
											2017-05-23 14:05:07 -07:00
+								      flush(() => {
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								        element.confirmDeleteOverlay.open.lastCall.returnValue.then(() => {
 								          const dialog =
 								              this.confirmDeleteOverlay.querySelector('#confirmDeleteComment');
 								          dialog.message = 'removal reason';
-												Fix gr-diff-comment_test in Firefox, Safari

Change-Id: I0d11ffa48c254622cbc86ec7c0ce265f24212859

											
										
										
											2017-05-23 14:05:07 -07:00
+								          element._handleConfirmDeleteComment();
 								          assert.isTrue(element.$.restAPI.deleteComment.calledWith(
 , 0xDEADBEEF, 'baf0414d_60047215', 'removal reason'));
 								          done();
 								        });
-												UI for comments deletion by admins

This change depends on API implemented in Change 105052.

Feature: Issue 4644
Change-Id: I91137aaa69eef419e08c8a568cef9350d8a1448b

											
										
										
											2017-05-08 10:40:06 -07:00
+								      });
 								    });
-												Report timing for updating diff comment drafts

Record the time it takes to save, update and delete comments starting
with the handlers for user corresponding interactions.

Change-Id: I9f22dc2e015fa46afcd5d531a3c0d4906e0bec89

											
										
										
											2018-05-14 12:59:23 -07:00
 								    suite('draft update reporting', () => {
-												Optionally log timing baselines with timer object

The gr-reporting "time" and "timeEnd" methods provide a convenient
mechanism for PolyGerrit components to record timings. However, because
they record the start time in a global dictionary keyed by the timing
name, they do not work well when multiple timers with the same key may
be reported simultaneously.

This multiple-timer scenario can come about when creating diff drafts,
which uses the CreateDraftComment timing key to time each draft,
potentially overwriting timers for earlier requests.

      Create      Create       Draft 1     Draft 2
      Draft 1     Draft 2      Created     Created
         |           |            |           |
         +------------------------+           |
         |           |            |           |
         |           +------------------------+
         |           |            |           |
Time ----+-----------+------------+-----------+---------------->
         |           |            |           |
        Save        Save        Timer    Timer attempts
        Timer       Timer       Ended    to end, but no
       Baseline    Baseline             timer is running!
                 (Overwrite!)

Provide a new method to record timing using timer objects that do not
store start times statefully. This gives a simple tool for the
concurrent timer cases, while preserving the convenient interface for
the timers for which concurrency is not an issue.

Change-Id: Ia5c030a16c87537700928df71a175821770e6814

											
										
										
											2018-06-13 14:14:38 -07:00
+								      let endStub;
 								      let getTimerStub;
-												Report timing for updating diff comment drafts

Record the time it takes to save, update and delete comments starting
with the handlers for user corresponding interactions.

Change-Id: I9f22dc2e015fa46afcd5d531a3c0d4906e0bec89

											
										
										
											2018-05-14 12:59:23 -07:00
+								      let mockEvent;
 								      setup(() => {
 								        mockEvent = {preventDefault() {}};
 								        sandbox.stub(element, 'save')
 								            .returns(Promise.resolve({}));
 								        sandbox.stub(element, '_discardDraft')
 								            .returns(Promise.resolve({}));
-												Optionally log timing baselines with timer object

The gr-reporting "time" and "timeEnd" methods provide a convenient
mechanism for PolyGerrit components to record timings. However, because
they record the start time in a global dictionary keyed by the timing
name, they do not work well when multiple timers with the same key may
be reported simultaneously.

This multiple-timer scenario can come about when creating diff drafts,
which uses the CreateDraftComment timing key to time each draft,
potentially overwriting timers for earlier requests.

      Create      Create       Draft 1     Draft 2
      Draft 1     Draft 2      Created     Created
         |           |            |           |
         +------------------------+           |
         |           |            |           |
         |           +------------------------+
         |           |            |           |
Time ----+-----------+------------+-----------+---------------->
         |           |            |           |
        Save        Save        Timer    Timer attempts
        Timer       Timer       Ended    to end, but no
       Baseline    Baseline             timer is running!
                 (Overwrite!)

Provide a new method to record timing using timer objects that do not
store start times statefully. This gives a simple tool for the
concurrent timer cases, while preserving the convenient interface for
the timers for which concurrency is not an issue.

Change-Id: Ia5c030a16c87537700928df71a175821770e6814

											
										
										
											2018-06-13 14:14:38 -07:00
+								        endStub = sinon.stub();
 								        getTimerStub = sandbox.stub(element.$.reporting, 'getTimer')
 								            .returns({end: endStub});
-												Report timing for updating diff comment drafts

Record the time it takes to save, update and delete comments starting
with the handlers for user corresponding interactions.

Change-Id: I9f22dc2e015fa46afcd5d531a3c0d4906e0bec89

											
										
										
											2018-05-14 12:59:23 -07:00
+								      });
 								      test('create', () => {
 								        element.comment = {};
 								        return element._handleSave(mockEvent).then(() => {
-												Optionally log timing baselines with timer object

The gr-reporting "time" and "timeEnd" methods provide a convenient
mechanism for PolyGerrit components to record timings. However, because
they record the start time in a global dictionary keyed by the timing
name, they do not work well when multiple timers with the same key may
be reported simultaneously.

This multiple-timer scenario can come about when creating diff drafts,
which uses the CreateDraftComment timing key to time each draft,
potentially overwriting timers for earlier requests.

      Create      Create       Draft 1     Draft 2
      Draft 1     Draft 2      Created     Created
         |           |            |           |
         +------------------------+           |
         |           |            |           |
         |           +------------------------+
         |           |            |           |
Time ----+-----------+------------+-----------+---------------->
         |           |            |           |
        Save        Save        Timer    Timer attempts
        Timer       Timer       Ended    to end, but no
       Baseline    Baseline             timer is running!
                 (Overwrite!)

Provide a new method to record timing using timer objects that do not
store start times statefully. This gives a simple tool for the
concurrent timer cases, while preserving the convenient interface for
the timers for which concurrency is not an issue.

Change-Id: Ia5c030a16c87537700928df71a175821770e6814

											
										
										
											2018-06-13 14:14:38 -07:00
+								          assert.isTrue(endStub.calledOnce);
 								          assert.isTrue(getTimerStub.calledOnce);
 								          assert.equal(getTimerStub.lastCall.args[0], 'CreateDraftComment');
-												Report timing for updating diff comment drafts

Record the time it takes to save, update and delete comments starting
with the handlers for user corresponding interactions.

Change-Id: I9f22dc2e015fa46afcd5d531a3c0d4906e0bec89

											
										
										
											2018-05-14 12:59:23 -07:00
+								        });
 								      });
 								      test('update', () => {
 								        element.comment = {id: 'abc_123'};
 								        return element._handleSave(mockEvent).then(() => {
-												Optionally log timing baselines with timer object

The gr-reporting "time" and "timeEnd" methods provide a convenient
mechanism for PolyGerrit components to record timings. However, because
they record the start time in a global dictionary keyed by the timing
name, they do not work well when multiple timers with the same key may
be reported simultaneously.

This multiple-timer scenario can come about when creating diff drafts,
which uses the CreateDraftComment timing key to time each draft,
potentially overwriting timers for earlier requests.

      Create      Create       Draft 1     Draft 2
      Draft 1     Draft 2      Created     Created
         |           |            |           |
         +------------------------+           |
         |           |            |           |
         |           +------------------------+
         |           |            |           |
Time ----+-----------+------------+-----------+---------------->
         |           |            |           |
        Save        Save        Timer    Timer attempts
        Timer       Timer       Ended    to end, but no
       Baseline    Baseline             timer is running!
                 (Overwrite!)

Provide a new method to record timing using timer objects that do not
store start times statefully. This gives a simple tool for the
concurrent timer cases, while preserving the convenient interface for
the timers for which concurrency is not an issue.

Change-Id: Ia5c030a16c87537700928df71a175821770e6814

											
										
										
											2018-06-13 14:14:38 -07:00
+								          assert.isTrue(endStub.calledOnce);
 								          assert.isTrue(getTimerStub.calledOnce);
 								          assert.equal(getTimerStub.lastCall.args[0], 'UpdateDraftComment');
-												Report timing for updating diff comment drafts

Record the time it takes to save, update and delete comments starting
with the handlers for user corresponding interactions.

Change-Id: I9f22dc2e015fa46afcd5d531a3c0d4906e0bec89

											
										
										
											2018-05-14 12:59:23 -07:00
+								        });
 								      });
 								      test('discard', () => {
 								        element.comment = {id: 'abc_123'};
 								        sandbox.stub(element, '_closeConfirmDiscardOverlay');
 								        return element._handleConfirmDiscard(mockEvent).then(() => {
-												Optionally log timing baselines with timer object

The gr-reporting "time" and "timeEnd" methods provide a convenient
mechanism for PolyGerrit components to record timings. However, because
they record the start time in a global dictionary keyed by the timing
name, they do not work well when multiple timers with the same key may
be reported simultaneously.

This multiple-timer scenario can come about when creating diff drafts,
which uses the CreateDraftComment timing key to time each draft,
potentially overwriting timers for earlier requests.

      Create      Create       Draft 1     Draft 2
      Draft 1     Draft 2      Created     Created
         |           |            |           |
         +------------------------+           |
         |           |            |           |
         |           +------------------------+
         |           |            |           |
Time ----+-----------+------------+-----------+---------------->
         |           |            |           |
        Save        Save        Timer    Timer attempts
        Timer       Timer       Ended    to end, but no
       Baseline    Baseline             timer is running!
                 (Overwrite!)

Provide a new method to record timing using timer objects that do not
store start times statefully. This gives a simple tool for the
concurrent timer cases, while preserving the convenient interface for
the timers for which concurrency is not an issue.

Change-Id: Ia5c030a16c87537700928df71a175821770e6814

											
										
										
											2018-06-13 14:14:38 -07:00
+								          assert.isTrue(endStub.calledOnce);
 								          assert.isTrue(getTimerStub.calledOnce);
 								          assert.equal(getTimerStub.lastCall.args[0], 'DiscardDraftComment');
-												Report timing for updating diff comment drafts

Record the time it takes to save, update and delete comments starting
with the handlers for user corresponding interactions.

Change-Id: I9f22dc2e015fa46afcd5d531a3c0d4906e0bec89

											
										
										
											2018-05-14 12:59:23 -07:00
+								        });
 								      });
 								    });
-												Report time between draft comment actions

Report the time between create, update or discard flows are initiated on
diff draft comments.

Change-Id: I71b2f955bfa65dde57307d67fda45069bffa02c0

											
										
										
											2018-06-19 17:03:43 -07:00
 								    test('edit reports interaction', () => {
 								      const reportStub = sandbox.stub(element.$.reporting,
 								          'recordDraftInteraction');
 								      MockInteractions.tap(element.$$('.edit'));
 								      assert.isTrue(reportStub.calledOnce);
 								    });
 								    test('discard reports interaction', () => {
 								      const reportStub = sandbox.stub(element.$.reporting,
 								          'recordDraftInteraction');
 								      element.draft = true;
 								      MockInteractions.tap(element.$$('.discard'));
 								      assert.isTrue(reportStub.calledOnce);
 								    });
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								  });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								  suite('gr-diff-comment draft tests', () => {
 								    let element;
 								    let sandbox;
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								    setup(() => {
-												gr-request/gr-ajax cleanup (gr-diff-comment)

Bug: Issue 3988
Change-Id: I0c100a0b77a256c1eb34f94e8fff0515add5dea1

											
										
										
											2016-05-03 15:14:57 -04:00
+								      stub('gr-rest-api-interface', {
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								        getAccount() { return Promise.resolve(null); },
 								        saveDiffDraft() {
-												gr-request/gr-ajax cleanup (gr-diff-comment)

Bug: Issue 3988
Change-Id: I0c100a0b77a256c1eb34f94e8fff0515add5dea1

											
										
										
											2016-05-03 15:14:57 -04:00
+								          return Promise.resolve({
 								            ok: true,
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								            text() {
-												gr-request/gr-ajax cleanup (gr-diff-comment)

Bug: Issue 3988
Change-Id: I0c100a0b77a256c1eb34f94e8fff0515add5dea1

											
										
										
											2016-05-03 15:14:57 -04:00
+								              return Promise.resolve(
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								                  ')]}\'\n{' +
-												gr-request/gr-ajax cleanup (gr-diff-comment)

Bug: Issue 3988
Change-Id: I0c100a0b77a256c1eb34f94e8fff0515add5dea1

											
										
										
											2016-05-03 15:14:57 -04:00
+								                  '"id": "baf0414d_40572e03",' +
 								                  '"path": "/path/to/file",' +
 								                  '"line": 5,' +
 								                  '"updated": "2015-12-08 21:52:36.177000000",' +
 								                  '"message": "saved!"' +
 								                '}'
 								              );
 								            },
 								          });
 								        },
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								        removeChangeReviewer() {
-												gr-request/gr-ajax cleanup (gr-diff-comment)

Bug: Issue 3988
Change-Id: I0c100a0b77a256c1eb34f94e8fff0515add5dea1

											
										
										
											2016-05-03 15:14:57 -04:00
+								          return Promise.resolve({ok: true});
 								        },
 								      });
-												Fix 'gr-diff-comment' test when run multiple times

The test worked fine on CI since they are run with a clean profile.
When tests were run in a normal browser profile manually, tests
'draft creation/cancelation' and 'draft saving/editing' failed
alternately because of local storage use for saving draft comments.

Since these tests do not test local storage (yet), we can just create
a stub for 'gr-storage#getDraftComment' which simulates a clean state.

Change-Id: Ibb63be4f1c395d47e0022f63d0d2ba0a7c87b137

											
										
										
											2016-06-05 12:20:11 +02:00
+								      stub('gr-storage', {
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								        getDraftComment() { return null; },
-												Fix 'gr-diff-comment' test when run multiple times

The test worked fine on CI since they are run with a clean profile.
When tests were run in a normal browser profile manually, tests
'draft creation/cancelation' and 'draft saving/editing' failed
alternately because of local storage use for saving draft comments.

Since these tests do not test local storage (yet), we can just create
a stub for 'gr-storage#getDraftComment' which simulates a clean state.

Change-Id: Ibb63be4f1c395d47e0022f63d0d2ba0a7c87b137

											
										
										
											2016-06-05 12:20:11 +02:00
+								      });
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								      element = fixture('draft');
 								      element.changeNum = 42;
 								      element.patchNum = 1;
-												Fix PolyGerrit tests

Change-Id: Iaac3880d6a3cfc8ae14f27ecef6b296e80dd80ed

											
										
										
											2016-02-05 18:22:05 -08:00
+								      element.editing = false;
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								      element.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
+								        __commentSide: 'right',
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								        __draft: true,
 								        __draftID: 'temp_draft_id',
 								        path: '/path/to/file',
 								        line: 5,
 								      };
-												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.commentSide = 'right';
-												Remove draft comment from local storage upon discard

Previously, when a user discarded a draft comment, the draft was still
stored in local storage. If they tried to reply to a comment on the same
line, the previous message appeared when it shouldn't have. This change
removes drafts from local storage when they are discarded.

Bug: Issue 4361
Change-Id: Id234676972a21a879e68e754968abf7008098cf6

											
										
										
											2016-12-01 10:55:14 -08:00
+								      sandbox = sinon.sandbox.create();
 								    });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								    teardown(() => {
-												Remove draft comment from local storage upon discard

Previously, when a user discarded a draft comment, the draft was still
stored in local storage. If they tried to reply to a comment on the same
line, the previous message appeared when it shouldn't have. This change
removes drafts from local storage when they are discarded.

Bug: Issue 4361
Change-Id: Id234676972a21a879e68e754968abf7008098cf6

											
										
										
											2016-12-01 10:55:14 -08:00
+								      sandbox.restore();
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								    });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								    test('button visibility states', () => {
-												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
+								      element.showActions = false;
-												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
+								      assert.isTrue(element.$$('.humanActions').hasAttribute('hidden'));
 								      assert.isTrue(element.$$('.robotActions').hasAttribute('hidden'));
-												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
+								      element.showActions = true;
-												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
+								      assert.isFalse(element.$$('.humanActions').hasAttribute('hidden'));
 								      assert.isTrue(element.$$('.robotActions').hasAttribute('hidden'));
-												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
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								      element.draft = true;
 								      assert.isTrue(isVisible(element.$$('.edit')), 'edit is visible');
 								      assert.isTrue(isVisible(element.$$('.discard')), 'discard is visible');
 								      assert.isFalse(isVisible(element.$$('.save')), 'save is not visible');
 								      assert.isFalse(isVisible(element.$$('.cancel')), 'cancel is not visible');
-												Allow toggling resolved outside editing state

A recent change modified some comment editing UX. As a consequence, the
save button disabled state was erroneously based entirely on whether or
not the comment message had changed.

With this change:
- Save disabled state on a comment takes into account resolved state
- The resolved checkbox is always visible on an expanded draft comment
- When the resolved checkbox is modified on a non-`editing` draft
  comment, it is saved immediately

Bug: Issue 6023
Change-Id: I40b0b280129e5a76c13e38c97525f91a8e56482d

											
										
										
											2017-12-05 11:03:52 -08:00
+								      assert.isTrue(isVisible(element.$$('.resolve')), 'resolve is visible');
-												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
+								      assert.isFalse(element.$$('.humanActions').hasAttribute('hidden'));
 								      assert.isTrue(element.$$('.robotActions').hasAttribute('hidden'));
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
 								      element.editing = true;
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								      flushAsynchronousOperations();
-												Fix issues detected by 'JSHint' and 'JSCS'

Change-Id: Ia535be02d19f09e716f00ec8819ba785010798f7

											
										
										
											2016-02-02 21:02:42 +01:00
+								      assert.isFalse(isVisible(element.$$('.edit')), 'edit is not visible');
-												Hide "Discard" button while editing comment

Bug: Issue 7491
Change-Id: I3514fd3f2ba63f138cd6eb52d32034d1ec8e47b0

											
										
										
											2017-11-01 12:15:19 -07:00
+								      assert.isFalse(isVisible(element.$$('.discard')), 'discard not visible');
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								      assert.isTrue(isVisible(element.$$('.save')), 'save is visible');
-												Remove hidden attribute from cancel button

The hidden attribute was erroneously left on the cancel button in diff
comments, causing it to not show up by default.

It showed up upon editing an existing draft because the hideOnPublished
CSS overrode the hack for the [hidden] attribute.

In addition, the buggy behavior was actually enforced by a buggy test --
it asserted that the button was not visible, but was labelled as "Cancel
is visible".

Bug: Issue 7664
Change-Id: I9e08c33fc4adf0f1465a52055a3308210625ffde

											
										
										
											2017-11-06 17:02:06 -08:00
+								      assert.isTrue(isVisible(element.$$('.cancel')), 'cancel is visible');
-												Add resolvable comments checkbox

Adds the 'resolved' checkbox to the front end. Unresolved comment
threads are indicated by #fcfaa6 as background-color, whereas resolved
threads have the background #fcfad6.

Feature: Issue 4879
Change-Id: Ie1eeba61ccba559f89b707542acab2198c99b8a7

											
										
										
											2017-01-04 16:45:21 -08:00
+								      assert.isTrue(isVisible(element.$$('.resolve')), 'resolve is visible');
-												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
+								      assert.isFalse(element.$$('.humanActions').hasAttribute('hidden'));
 								      assert.isTrue(element.$$('.robotActions').hasAttribute('hidden'));
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
-												Fix issues detected by 'JSHint' and 'JSCS'

Change-Id: Ia535be02d19f09e716f00ec8819ba785010798f7

											
										
										
											2016-02-02 21:02:42 +01:00
+								      element.draft = false;
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								      element.editing = false;
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								      flushAsynchronousOperations();
-												Fix issues detected by 'JSHint' and 'JSCS'

Change-Id: Ia535be02d19f09e716f00ec8819ba785010798f7

											
										
										
											2016-02-02 21:02:42 +01:00
+								      assert.isFalse(isVisible(element.$$('.edit')), 'edit is not visible');
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								      assert.isFalse(isVisible(element.$$('.discard')),
 								          'discard is not visible');
 								      assert.isFalse(isVisible(element.$$('.save')), 'save is not visible');
 								      assert.isFalse(isVisible(element.$$('.cancel')), 'cancel is not visible');
-												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
+								      assert.isFalse(element.$$('.humanActions').hasAttribute('hidden'));
 								      assert.isTrue(element.$$('.robotActions').hasAttribute('hidden'));
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
-												Implement 'Quote' button on diff comments

Also
+ Cleans up a TODO for a bug that isn’t existent anymore.
+ Doesn’t show cancel button unless editing a draft that has already
  been saved once.

Bug: Issue 3783
Change-Id: I102d598f64e4f37eca41ff428b574e8230e298cf

											
										
										
											2016-01-28 18:07:26 -05:00
+								      element.comment.id = 'foo';
-												Fix PolyGerrit tests

Change-Id: Iaac3880d6a3cfc8ae14f27ecef6b296e80dd80ed

											
										
										
											2016-02-05 18:22:05 -08:00
+								      element.draft = true;
-												Implement 'Quote' button on diff comments

Also
+ Cleans up a TODO for a bug that isn’t existent anymore.
+ Doesn’t show cancel button unless editing a draft that has already
  been saved once.

Bug: Issue 3783
Change-Id: I102d598f64e4f37eca41ff428b574e8230e298cf

											
										
										
											2016-01-28 18:07:26 -05:00
+								      element.editing = true;
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								      flushAsynchronousOperations();
-												Implement 'Quote' button on diff comments

Also
+ Cleans up a TODO for a bug that isn’t existent anymore.
+ Doesn’t show cancel button unless editing a draft that has already
  been saved once.

Bug: Issue 3783
Change-Id: I102d598f64e4f37eca41ff428b574e8230e298cf

											
										
										
											2016-01-28 18:07:26 -05:00
+								      assert.isTrue(isVisible(element.$$('.cancel')), 'cancel is visible');
-												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
+								      assert.isFalse(element.$$('.humanActions').hasAttribute('hidden'));
 								      assert.isTrue(element.$$('.robotActions').hasAttribute('hidden'));
 								      element.isRobotComment = true;
 								      element.draft = true;
 								      assert.isTrue(element.$$('.humanActions').hasAttribute('hidden'));
 								      assert.isFalse(element.$$('.robotActions').hasAttribute('hidden'));
 								      // It is not expected to see Robot comment drafts, but if they appear,
 								      // they will behave the same as non-drafts.
 								      element.draft = false;
 								      assert.isTrue(element.$$('.humanActions').hasAttribute('hidden'));
 								      assert.isFalse(element.$$('.robotActions').hasAttribute('hidden'));
-												Robot comment styling updates

- Removes the blue background color
- Moves the robot comment specific buttons to be left aligned
- Makes the robot run ID selectable
- Displays the run ID as plain text if there's not a link

Bug: Issue 8514
Change-Id: Ic72caaf76977f5485655ef9ed45b4a7350397a9b

											
										
										
											2018-03-14 15:26:45 -07:00
 								      // A robot comment with run ID should display plain text.
 								      element.set(['comment', 'robot_run_id'], 'text');
 								      element.editing = false;
 								      element.collapsed = false;
 								      flushAsynchronousOperations();
 								      assert.isNotOk(element.$$('.robotRun.link'));
 								      assert.notEqual(getComputedStyle(element.$$('.robotRun.text')).display,
 								          'none');
 								      // A robot comment with run ID and url should display a link.
 								      element.set(['comment', 'url'], '/path/to/run');
 								      flushAsynchronousOperations();
 								      assert.notEqual(getComputedStyle(element.$$('.robotRun.link')).display,
 								          'none');
 								      assert.equal(getComputedStyle(element.$$('.robotRun.text')).display,
 								          'none');
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								    });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								    test('collapsible drafts', () => {
-												Keyboard shortcuts to expand and collapse all comments

This change adds keyboard shortcuts to the "gr-diff-comment-thread"
expand all comments when 'e' is pressed and collapse all comments when
'shift + e' is pressed. Note that the keyboard event is detected on the
thread instead of the comment to minimize the number of events getting
triggered.

Feature: Issue 4738
Change-Id: Iab77349bd1527d7af5e05a827919a78a86909835

											
										
										
											2016-10-10 17:31:56 -07:00
+								      assert.isTrue(element.collapsed);
-												Wiki-like formatting for PolyGerrit comments

This change is the PolyGerrit counterpart to [1].

Nicer rendering for reviewer comments in PolyGerrit using the Gerrit
Wiki-like format. Whereas, formerly, PG comments were set in PRE blocks
using monospaced font so that the original format and alignment of the
comment can be directly viewed. This change allows comments to default
to a variable-width font with wrapping while separately styling blocks
intended to be pre-formatted text, quotes and lists.

The logic to parse comment text into blocks is borrowed from the Java
implementation found in [1]. Test cases are additionally translated from
this change to ensure coincident behavior.

Introduces GR-FORMATTED-TEXT to display these comments, and which uses a
similar interface to GR-LINKED-TEXT. Much like [1], the comment is
parsed into a list of blocks. These blocks are then mapped to the DOM
nodes that get attached inside the element.

[1] I8e11d363b80bff0b6395f56e210b636f68db36fa

Feature: Issue 4861
Change-Id: I245d6782e2fd8982ac3eda438fe4ca80f3658195

											
										
										
											2016-11-08 15:49:05 -08:00
+								      assert.isFalse(isVisible(element.$$('gr-formatted-text')),
 								          'gr-formatted-text is not visible');
-												Allow for comments to be collapsible

Previously in Polygerrit, comments were always expanded. You could
always see the full comment (if multiline) and any applicable actions.

This change creates a collapsed comment view.  It adds a preview of the
text to the header row when collapsed, and can be toggled open when any
part of the header is clicked.

Bug: Issue 4698
Change-Id: Idca5caf92eb32518b6737dbb5a3380d227513996

											
										
										
											2016-10-06 10:18:32 -07:00
+								      assert.isFalse(isVisible(element.$$('.actions')),
 								          'actions are not visible');
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								      assert.isNotOk(element.textarea, 'textarea is not visible');
-												Allow for comments to be collapsible

Previously in Polygerrit, comments were always expanded. You could
always see the full comment (if multiline) and any applicable actions.

This change creates a collapsed comment view.  It adds a preview of the
text to the header row when collapsed, and can be toggled open when any
part of the header is clicked.

Bug: Issue 4698
Change-Id: Idca5caf92eb32518b6737dbb5a3380d227513996

											
										
										
											2016-10-06 10:18:32 -07:00
+								      assert.isTrue(isVisible(element.$$('.collapsedContent')),
 								          'header middle content is visible');
 								      MockInteractions.tap(element.$.header);
-												Keyboard shortcuts to expand and collapse all comments

This change adds keyboard shortcuts to the "gr-diff-comment-thread"
expand all comments when 'e' is pressed and collapse all comments when
'shift + e' is pressed. Note that the keyboard event is detected on the
thread instead of the comment to minimize the number of events getting
triggered.

Feature: Issue 4738
Change-Id: Iab77349bd1527d7af5e05a827919a78a86909835

											
										
										
											2016-10-10 17:31:56 -07:00
+								      assert.isFalse(element.collapsed);
-												Wiki-like formatting for PolyGerrit comments

This change is the PolyGerrit counterpart to [1].

Nicer rendering for reviewer comments in PolyGerrit using the Gerrit
Wiki-like format. Whereas, formerly, PG comments were set in PRE blocks
using monospaced font so that the original format and alignment of the
comment can be directly viewed. This change allows comments to default
to a variable-width font with wrapping while separately styling blocks
intended to be pre-formatted text, quotes and lists.

The logic to parse comment text into blocks is borrowed from the Java
implementation found in [1]. Test cases are additionally translated from
this change to ensure coincident behavior.

Introduces GR-FORMATTED-TEXT to display these comments, and which uses a
similar interface to GR-LINKED-TEXT. Much like [1], the comment is
parsed into a list of blocks. These blocks are then mapped to the DOM
nodes that get attached inside the element.

[1] I8e11d363b80bff0b6395f56e210b636f68db36fa

Feature: Issue 4861
Change-Id: I245d6782e2fd8982ac3eda438fe4ca80f3658195

											
										
										
											2016-11-08 15:49:05 -08:00
+								      assert.isTrue(isVisible(element.$$('gr-formatted-text')),
 								          'gr-formatted-text is visible');
-												Allow for comments to be collapsible

Previously in Polygerrit, comments were always expanded. You could
always see the full comment (if multiline) and any applicable actions.

This change creates a collapsed comment view.  It adds a preview of the
text to the header row when collapsed, and can be toggled open when any
part of the header is clicked.

Bug: Issue 4698
Change-Id: Idca5caf92eb32518b6737dbb5a3380d227513996

											
										
										
											2016-10-06 10:18:32 -07:00
+								      assert.isTrue(isVisible(element.$$('.actions')),
 								          'actions are visible');
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								      assert.isNotOk(element.textarea, 'textarea is not visible');
-												Allow for comments to be collapsible

Previously in Polygerrit, comments were always expanded. You could
always see the full comment (if multiline) and any applicable actions.

This change creates a collapsed comment view.  It adds a preview of the
text to the header row when collapsed, and can be toggled open when any
part of the header is clicked.

Bug: Issue 4698
Change-Id: Idca5caf92eb32518b6737dbb5a3380d227513996

											
										
										
											2016-10-06 10:18:32 -07:00
+								      assert.isFalse(isVisible(element.$$('.collapsedContent')),
 								          'header middle content is is not visible');
 								      // When the edit button is pressed, should still see the actions
 								      // and also textarea
 								      MockInteractions.tap(element.$$('.edit'));
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								      flushAsynchronousOperations();
-												Keyboard shortcuts to expand and collapse all comments

This change adds keyboard shortcuts to the "gr-diff-comment-thread"
expand all comments when 'e' is pressed and collapse all comments when
'shift + e' is pressed. Note that the keyboard event is detected on the
thread instead of the comment to minimize the number of events getting
triggered.

Feature: Issue 4738
Change-Id: Iab77349bd1527d7af5e05a827919a78a86909835

											
										
										
											2016-10-10 17:31:56 -07:00
+								      assert.isFalse(element.collapsed);
-												Wiki-like formatting for PolyGerrit comments

This change is the PolyGerrit counterpart to [1].

Nicer rendering for reviewer comments in PolyGerrit using the Gerrit
Wiki-like format. Whereas, formerly, PG comments were set in PRE blocks
using monospaced font so that the original format and alignment of the
comment can be directly viewed. This change allows comments to default
to a variable-width font with wrapping while separately styling blocks
intended to be pre-formatted text, quotes and lists.

The logic to parse comment text into blocks is borrowed from the Java
implementation found in [1]. Test cases are additionally translated from
this change to ensure coincident behavior.

Introduces GR-FORMATTED-TEXT to display these comments, and which uses a
similar interface to GR-LINKED-TEXT. Much like [1], the comment is
parsed into a list of blocks. These blocks are then mapped to the DOM
nodes that get attached inside the element.

[1] I8e11d363b80bff0b6395f56e210b636f68db36fa

Feature: Issue 4861
Change-Id: I245d6782e2fd8982ac3eda438fe4ca80f3658195

											
										
										
											2016-11-08 15:49:05 -08:00
+								      assert.isFalse(isVisible(element.$$('gr-formatted-text')),
 								          'gr-formatted-text is not visible');
-												Allow for comments to be collapsible

Previously in Polygerrit, comments were always expanded. You could
always see the full comment (if multiline) and any applicable actions.

This change creates a collapsed comment view.  It adds a preview of the
text to the header row when collapsed, and can be toggled open when any
part of the header is clicked.

Bug: Issue 4698
Change-Id: Idca5caf92eb32518b6737dbb5a3380d227513996

											
										
										
											2016-10-06 10:18:32 -07:00
+								      assert.isTrue(isVisible(element.$$('.actions')),
 								          'actions are visible');
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								      assert.isTrue(isVisible(element.textarea), 'textarea is visible');
-												Allow for comments to be collapsible

Previously in Polygerrit, comments were always expanded. You could
always see the full comment (if multiline) and any applicable actions.

This change creates a collapsed comment view.  It adds a preview of the
text to the header row when collapsed, and can be toggled open when any
part of the header is clicked.

Bug: Issue 4698
Change-Id: Idca5caf92eb32518b6737dbb5a3380d227513996

											
										
										
											2016-10-06 10:18:32 -07:00
+								      assert.isFalse(isVisible(element.$$('.collapsedContent')),
 								          'header middle content is not visible');
 								      // When toggle again, everything should be hidden except for textarea
 								      // and header middle content should be visible
 								      MockInteractions.tap(element.$.header);
-												Keyboard shortcuts to expand and collapse all comments

This change adds keyboard shortcuts to the "gr-diff-comment-thread"
expand all comments when 'e' is pressed and collapse all comments when
'shift + e' is pressed. Note that the keyboard event is detected on the
thread instead of the comment to minimize the number of events getting
triggered.

Feature: Issue 4738
Change-Id: Iab77349bd1527d7af5e05a827919a78a86909835

											
										
										
											2016-10-10 17:31:56 -07:00
+								      assert.isTrue(element.collapsed);
-												Wiki-like formatting for PolyGerrit comments

This change is the PolyGerrit counterpart to [1].

Nicer rendering for reviewer comments in PolyGerrit using the Gerrit
Wiki-like format. Whereas, formerly, PG comments were set in PRE blocks
using monospaced font so that the original format and alignment of the
comment can be directly viewed. This change allows comments to default
to a variable-width font with wrapping while separately styling blocks
intended to be pre-formatted text, quotes and lists.

The logic to parse comment text into blocks is borrowed from the Java
implementation found in [1]. Test cases are additionally translated from
this change to ensure coincident behavior.

Introduces GR-FORMATTED-TEXT to display these comments, and which uses a
similar interface to GR-LINKED-TEXT. Much like [1], the comment is
parsed into a list of blocks. These blocks are then mapped to the DOM
nodes that get attached inside the element.

[1] I8e11d363b80bff0b6395f56e210b636f68db36fa

Feature: Issue 4861
Change-Id: I245d6782e2fd8982ac3eda438fe4ca80f3658195

											
										
										
											2016-11-08 15:49:05 -08:00
+								      assert.isFalse(isVisible(element.$$('gr-formatted-text')),
 								          'gr-formatted-text is not visible');
-												Allow for comments to be collapsible

Previously in Polygerrit, comments were always expanded. You could
always see the full comment (if multiline) and any applicable actions.

This change creates a collapsed comment view.  It adds a preview of the
text to the header row when collapsed, and can be toggled open when any
part of the header is clicked.

Bug: Issue 4698
Change-Id: Idca5caf92eb32518b6737dbb5a3380d227513996

											
										
										
											2016-10-06 10:18:32 -07:00
+								      assert.isFalse(isVisible(element.$$('.actions')),
 								          'actions are not visible');
-												Add gr-autogrow-textarea to gr-diff-comment

This replaces iron-autogrow-textarea so that the diff comments can have
emoji support.

Change-Id: I8bfa31b789604f28aca0ff28dc5c0836afdb6005

											
										
										
											2017-05-03 10:03:35 -07:00
+								      assert.isFalse(isVisible(element.$$('gr-textarea')),
-												Allow for comments to be collapsible

Previously in Polygerrit, comments were always expanded. You could
always see the full comment (if multiline) and any applicable actions.

This change creates a collapsed comment view.  It adds a preview of the
text to the header row when collapsed, and can be toggled open when any
part of the header is clicked.

Bug: Issue 4698
Change-Id: Idca5caf92eb32518b6737dbb5a3380d227513996

											
										
										
											2016-10-06 10:18:32 -07:00
+								          'textarea is not visible');
 								      assert.isTrue(isVisible(element.$$('.collapsedContent')),
 								          'header middle content is visible');
 								      // When toggle again, textarea should remain open in the state it was
 								      // before
 								      MockInteractions.tap(element.$.header);
-												Wiki-like formatting for PolyGerrit comments

This change is the PolyGerrit counterpart to [1].

Nicer rendering for reviewer comments in PolyGerrit using the Gerrit
Wiki-like format. Whereas, formerly, PG comments were set in PRE blocks
using monospaced font so that the original format and alignment of the
comment can be directly viewed. This change allows comments to default
to a variable-width font with wrapping while separately styling blocks
intended to be pre-formatted text, quotes and lists.

The logic to parse comment text into blocks is borrowed from the Java
implementation found in [1]. Test cases are additionally translated from
this change to ensure coincident behavior.

Introduces GR-FORMATTED-TEXT to display these comments, and which uses a
similar interface to GR-LINKED-TEXT. Much like [1], the comment is
parsed into a list of blocks. These blocks are then mapped to the DOM
nodes that get attached inside the element.

[1] I8e11d363b80bff0b6395f56e210b636f68db36fa

Feature: Issue 4861
Change-Id: I245d6782e2fd8982ac3eda438fe4ca80f3658195

											
										
										
											2016-11-08 15:49:05 -08:00
+								      assert.isFalse(isVisible(element.$$('gr-formatted-text')),
 								          'gr-formatted-text is not visible');
-												Allow for comments to be collapsible

Previously in Polygerrit, comments were always expanded. You could
always see the full comment (if multiline) and any applicable actions.

This change creates a collapsed comment view.  It adds a preview of the
text to the header row when collapsed, and can be toggled open when any
part of the header is clicked.

Bug: Issue 4698
Change-Id: Idca5caf92eb32518b6737dbb5a3380d227513996

											
										
										
											2016-10-06 10:18:32 -07:00
+								      assert.isTrue(isVisible(element.$$('.actions')),
 								          'actions are visible');
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								      assert.isTrue(isVisible(element.textarea), 'textarea is visible');
-												Allow for comments to be collapsible

Previously in Polygerrit, comments were always expanded. You could
always see the full comment (if multiline) and any applicable actions.

This change creates a collapsed comment view.  It adds a preview of the
text to the header row when collapsed, and can be toggled open when any
part of the header is clicked.

Bug: Issue 4698
Change-Id: Idca5caf92eb32518b6737dbb5a3380d227513996

											
										
										
											2016-10-06 10:18:32 -07:00
+								      assert.isFalse(isVisible(element.$$('.collapsedContent')),
 								          'header middle content is not visible');
 								    });
-												Delete draft comment when saved with empty text

Recently, the comment editing UX was changed (the discard button was
removed from the editing view). This (obviously) made it impossible to
discard a draft comment whilst editing it.

Editing a comment, clearing the text, and saving now removes the
comment.

Bug: Issue 7832
Change-Id: I0dae814b9ce2e7a5b57530f839c708e59c215341

											
										
										
											2017-11-27 16:13:06 -08:00
+								    test('draft creation/cancellation', done => {
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								      assert.isFalse(element.editing);
 								      MockInteractions.tap(element.$$('.edit'));
 								      assert.isTrue(element.editing);
-												Cleanup of diff comment draft saving work

- Refactors the _editDraft property of gr-diff-comment to _messageText.
- Renames the gr-storage element as instantiated in gr-diff-comment from
  "localStorage" to "storage".
- The gr-storage diff comment functions are refactored to include
  "comment" in their names and to accept a location object rather than 4
  separate arguments.
- Added a comment describing the use of a promise in the _loadLocalDraft
  method of gr-diff-comment.
- Throttled the invocation of the _cleanupDrafts method of gr-storage to
  avoid potentially expensive crawls over all localStorage entries.
- Various other smaller fixes.

Bug: Issue 3787
Change-Id: Idf96051c0d56d6ce8b15f55ca2680363bd1ca805

											
										
										
											2016-05-23 13:53:10 -07:00
+								      element._messageText = '';
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								      const eraseMessageDraftSpy = sandbox.spy(element, '_eraseDraftComment');
-												Remove draft comment from local storage upon discard

Previously, when a user discarded a draft comment, the draft was still
stored in local storage. If they tried to reply to a comment on the same
line, the previous message appeared when it shouldn't have. This change
removes drafts from local storage when they are discarded.

Bug: Issue 4361
Change-Id: Id234676972a21a879e68e754968abf7008098cf6

											
										
										
											2016-12-01 10:55:14 -08:00
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								      // Save should be disabled on an empty message.
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								      let disabled = element.$$('.save').hasAttribute('disabled');
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								      assert.isTrue(disabled, 'save button should be disabled.');
-												Cleanup of diff comment draft saving work

- Refactors the _editDraft property of gr-diff-comment to _messageText.
- Renames the gr-storage element as instantiated in gr-diff-comment from
  "localStorage" to "storage".
- The gr-storage diff comment functions are refactored to include
  "comment" in their names and to accept a location object rather than 4
  separate arguments.
- Added a comment describing the use of a promise in the _loadLocalDraft
  method of gr-diff-comment.
- Throttled the invocation of the _cleanupDrafts method of gr-storage to
  avoid potentially expensive crawls over all localStorage entries.
- Various other smaller fixes.

Bug: Issue 3787
Change-Id: Idf96051c0d56d6ce8b15f55ca2680363bd1ca805

											
										
										
											2016-05-23 13:53:10 -07:00
+								      element._messageText = '     ';
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								      disabled = element.$$('.save').hasAttribute('disabled');
 								      assert.isTrue(disabled, 'save button should be disabled.');
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								      const updateStub = sinon.stub();
-												Cancel comment updates on discard

Fixes race condition triggering re-rendering of a deleted comment by
canceling debounced updates for `comment.editing` changes.

Bug: Issue 4319
Change-Id: I2a7578443783360088d6f65decd7dcb8be5e636b

											
										
										
											2016-08-05 15:05:50 -07:00
+								      element.addEventListener('comment-update', updateStub);
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								      let numDiscardEvents = 0;
 								      element.addEventListener('comment-discard', e => {
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								        numDiscardEvents++;
-												Remove draft comment from local storage upon discard

Previously, when a user discarded a draft comment, the draft was still
stored in local storage. If they tried to reply to a comment on the same
line, the previous message appeared when it shouldn't have. This change
removes drafts from local storage when they are discarded.

Bug: Issue 4361
Change-Id: Id234676972a21a879e68e754968abf7008098cf6

											
										
										
											2016-12-01 10:55:14 -08:00
+								        assert.isFalse(eraseMessageDraftSpy.called);
 								        if (numDiscardEvents === 2) {
-												Cancel comment updates on discard

Fixes race condition triggering re-rendering of a deleted comment by
canceling debounced updates for `comment.editing` changes.

Bug: Issue 4319
Change-Id: I2a7578443783360088d6f65decd7dcb8be5e636b

											
										
										
											2016-08-05 15:05:50 -07:00
+								          assert.isFalse(updateStub.called);
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								          done();
 								        }
 								      });
 								      MockInteractions.tap(element.$$('.cancel'));
-												Cancel comment updates on discard

Fixes race condition triggering re-rendering of a deleted comment by
canceling debounced updates for `comment.editing` changes.

Bug: Issue 4319
Change-Id: I2a7578443783360088d6f65decd7dcb8be5e636b

											
										
										
											2016-08-05 15:05:50 -07:00
+								      element.flushDebouncer('fire-update');
-												Escape only closes an empty comment box

Previously, the escape key closed and cancelled any in progress comment.
This was particularly painful for some who were used to a certain text
editor, so now escape only closes an in-progress comment if it's empty.

Bug: Issue 4816
Change-Id: I2749a995ebf914c4387261c387b008f6ce91dd86

											
										
										
											2016-11-02 14:18:48 -07:00
+								      element._messageText = '';
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								      flushAsynchronousOperations();
 								      MockInteractions.pressAndReleaseKeyOn(element.textarea, 27); // esc
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								    });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								    test('draft discard removes message from storage', done => {
-												Remove draft comment from local storage upon discard

Previously, when a user discarded a draft comment, the draft was still
stored in local storage. If they tried to reply to a comment on the same
line, the previous message appeared when it shouldn't have. This change
removes drafts from local storage when they are discarded.

Bug: Issue 4361
Change-Id: Id234676972a21a879e68e754968abf7008098cf6

											
										
										
											2016-12-01 10:55:14 -08:00
+								      element._messageText = '';
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								      const eraseMessageDraftSpy = sandbox.spy(element, '_eraseDraftComment');
-												Show confirmation dialog before destructively discarding draft comments

The discard confirm dialog is added alongside the delete confirm dialog
and the dialog opening/closing code is refactored to work on either. The
confirm discard dialog only appears if the draft message is savable.

Feature: Issue 6984
Change-Id: I6d88a8734fa7736f685796790e02437b10c81f00

											
										
										
											2017-10-18 13:22:43 -07:00
+								      sandbox.stub(element, '_closeConfirmDiscardOverlay');
-												Remove draft comment from local storage upon discard

Previously, when a user discarded a draft comment, the draft was still
stored in local storage. If they tried to reply to a comment on the same
line, the previous message appeared when it shouldn't have. This change
removes drafts from local storage when they are discarded.

Bug: Issue 4361
Change-Id: Id234676972a21a879e68e754968abf7008098cf6

											
										
										
											2016-12-01 10:55:14 -08:00
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								      element.addEventListener('comment-discard', e => {
-												Remove draft comment from local storage upon discard

Previously, when a user discarded a draft comment, the draft was still
stored in local storage. If they tried to reply to a comment on the same
line, the previous message appeared when it shouldn't have. This change
removes drafts from local storage when they are discarded.

Bug: Issue 4361
Change-Id: Id234676972a21a879e68e754968abf7008098cf6

											
										
										
											2016-12-01 10:55:14 -08:00
+								        assert.isTrue(eraseMessageDraftSpy.called);
 								        done();
 								      });
-												Show confirmation dialog before destructively discarding draft comments

The discard confirm dialog is added alongside the delete confirm dialog
and the dialog opening/closing code is refactored to work on either. The
confirm discard dialog only appears if the draft message is savable.

Feature: Issue 6984
Change-Id: I6d88a8734fa7736f685796790e02437b10c81f00

											
										
										
											2017-10-18 13:22:43 -07:00
+								      element._handleConfirmDiscard({preventDefault: sinon.stub()});
 								    });
-												Only erase unsaved drafts after save request succeeds

Unsaved diff drafts are kept in localstorage so they are not lost if
they do not get saved (for example, if the browser crashes). However,
this stored copy of the comment is cleared when the save request is
started, not after it succeeds. As such, if the save request fails (for
example, if the user credentials are invalid), the comment can be truly
lost.

With this change, the localstorage copy is only cleared after save
success. If the request fails, it allows the error message to appear
rather than showing a misleading "All comments saved" toast.

Bug: issue 7289
Change-Id: Id5c8144ecccec50de35f83af616b4e4915b62b5c

											
										
										
											2017-10-26 14:11:24 -07:00
+								    test('storage is cleared only after save success', () => {
-												Delete draft comment when saved with empty text

Recently, the comment editing UX was changed (the discard button was
removed from the editing view). This (obviously) made it impossible to
discard a draft comment whilst editing it.

Editing a comment, clearing the text, and saving now removes the
comment.

Bug: Issue 7832
Change-Id: I0dae814b9ce2e7a5b57530f839c708e59c215341

											
										
										
											2017-11-27 16:13:06 -08:00
+								      element._messageText = 'test';
-												Only erase unsaved drafts after save request succeeds

Unsaved diff drafts are kept in localstorage so they are not lost if
they do not get saved (for example, if the browser crashes). However,
this stored copy of the comment is cleared when the save request is
started, not after it succeeds. As such, if the save request fails (for
example, if the user credentials are invalid), the comment can be truly
lost.

With this change, the localstorage copy is only cleared after save
success. If the request fails, it allows the error message to appear
rather than showing a misleading "All comments saved" toast.

Bug: issue 7289
Change-Id: Id5c8144ecccec50de35f83af616b4e4915b62b5c

											
										
										
											2017-10-26 14:11:24 -07:00
+								      const eraseStub = sandbox.stub(element, '_eraseDraftComment');
 								      sandbox.stub(element.$.restAPI, 'getResponseObject')
 								          .returns(Promise.resolve({}));
 								      sandbox.stub(element, '_saveDraft').returns(Promise.resolve({ok: false}));
 								      const savePromise = element.save();
 								      assert.isFalse(eraseStub.called);
 								      return savePromise.then(() => {
 								        assert.isFalse(eraseStub.called);
 								        element._saveDraft.restore();
 								        sandbox.stub(element, '_saveDraft')
 								            .returns(Promise.resolve({ok: true}));
 								        return element.save().then(() => {
 								          assert.isTrue(eraseStub.called);
 								        });
 								      });
 								    });
-												Delete draft comment when saved with empty text

Recently, the comment editing UX was changed (the discard button was
removed from the editing view). This (obviously) made it impossible to
discard a draft comment whilst editing it.

Editing a comment, clearing the text, and saving now removes the
comment.

Bug: Issue 7832
Change-Id: I0dae814b9ce2e7a5b57530f839c708e59c215341

											
										
										
											2017-11-27 16:13:06 -08:00
+								    test('_computeSaveDisabled', () => {
-												Allow toggling resolved outside editing state

A recent change modified some comment editing UX. As a consequence, the
save button disabled state was erroneously based entirely on whether or
not the comment message had changed.

With this change:
- Save disabled state on a comment takes into account resolved state
- The resolved checkbox is always visible on an expanded draft comment
- When the resolved checkbox is modified on a non-`editing` draft
  comment, it is saved immediately

Bug: Issue 6023
Change-Id: I40b0b280129e5a76c13e38c97525f91a8e56482d

											
										
										
											2017-12-05 11:03:52 -08:00
+								      const comment = {unresolved: true};
 								      const msgComment = {message: 'test', unresolved: true};
 								      assert.equal(element._computeSaveDisabled('', comment, false), true);
 								      assert.equal(element._computeSaveDisabled('test', comment, false), false);
-												Allow convergent comment saves

Formerly, the save button would be disabled when attempting to edit a
comment to have the same content as what's already been saved. This can
be a confusing UX where it isn't clear why a comment cannot be saved.

Allow saving comments even when the text has not been changed.

Bug: Issue 8128
Change-Id: I615c38e0cc109ea87f58c9b8a9b7de28ec459b88

											
										
										
											2018-01-18 14:51:41 -08:00
+								      assert.equal(element._computeSaveDisabled('', msgComment, false), true);
-												Allow toggling resolved outside editing state

A recent change modified some comment editing UX. As a consequence, the
save button disabled state was erroneously based entirely on whether or
not the comment message had changed.

With this change:
- Save disabled state on a comment takes into account resolved state
- The resolved checkbox is always visible on an expanded draft comment
- When the resolved checkbox is modified on a non-`editing` draft
  comment, it is saved immediately

Bug: Issue 6023
Change-Id: I40b0b280129e5a76c13e38c97525f91a8e56482d

											
										
										
											2017-12-05 11:03:52 -08:00
+								      assert.equal(
-												Allow convergent comment saves

Formerly, the save button would be disabled when attempting to edit a
comment to have the same content as what's already been saved. This can
be a confusing UX where it isn't clear why a comment cannot be saved.

Allow saving comments even when the text has not been changed.

Bug: Issue 8128
Change-Id: I615c38e0cc109ea87f58c9b8a9b7de28ec459b88

											
										
										
											2018-01-18 14:51:41 -08:00
+								          element._computeSaveDisabled('test', msgComment, false), false);
-												Allow toggling resolved outside editing state

A recent change modified some comment editing UX. As a consequence, the
save button disabled state was erroneously based entirely on whether or
not the comment message had changed.

With this change:
- Save disabled state on a comment takes into account resolved state
- The resolved checkbox is always visible on an expanded draft comment
- When the resolved checkbox is modified on a non-`editing` draft
  comment, it is saved immediately

Bug: Issue 6023
Change-Id: I40b0b280129e5a76c13e38c97525f91a8e56482d

											
										
										
											2017-12-05 11:03:52 -08:00
+								      assert.equal(
 								          element._computeSaveDisabled('test2', msgComment, false), false);
 								      assert.equal(element._computeSaveDisabled('test', comment, true), false);
 								      assert.equal(element._computeSaveDisabled('', comment, true), true);
 								      assert.equal(element._computeSaveDisabled('', comment, false), true);
-												Delete draft comment when saved with empty text

Recently, the comment editing UX was changed (the discard button was
removed from the editing view). This (obviously) made it impossible to
discard a draft comment whilst editing it.

Editing a comment, clearing the text, and saving now removes the
comment.

Bug: Issue 7832
Change-Id: I0dae814b9ce2e7a5b57530f839c708e59c215341

											
										
										
											2017-11-27 16:13:06 -08:00
+								    });
-												Show confirmation dialog before destructively discarding draft comments

The discard confirm dialog is added alongside the delete confirm dialog
and the dialog opening/closing code is refactored to work on either. The
confirm discard dialog only appears if the draft message is savable.

Feature: Issue 6984
Change-Id: I6d88a8734fa7736f685796790e02437b10c81f00

											
										
										
											2017-10-18 13:22:43 -07:00
+								    suite('confirm discard', () => {
 								      let discardStub;
 								      let overlayStub;
 								      let mockEvent;
 								      setup(() => {
 								        discardStub = sandbox.stub(element, '_discardDraft');
-												Set focus in confirm dialog when discarding draft

Change-Id: I6d221c2ca4494586c06e87732f9d8de2434fd599

											
										
										
											2018-07-10 18:04:44 -07:00
+								        overlayStub = sandbox.stub(element, '_openOverlay')
 								            .returns(Promise.resolve());
-												Show confirmation dialog before destructively discarding draft comments

The discard confirm dialog is added alongside the delete confirm dialog
and the dialog opening/closing code is refactored to work on either. The
confirm discard dialog only appears if the draft message is savable.

Feature: Issue 6984
Change-Id: I6d88a8734fa7736f685796790e02437b10c81f00

											
										
										
											2017-10-18 13:22:43 -07:00
+								        mockEvent = {preventDefault: sinon.stub()};
 								      });
-												Restore confirm discard dialog for draft comments

Draft comments with message text should have a confirm dialog when
discarded to prevent accidental data loss.

This is a regression introduced by I0dae814.

Bug: Issue 7900
Change-Id: Ibd9829ccf36a551445282e5cb0d37c1a6df46ab9

											
										
										
											2017-12-05 11:40:43 -08:00
+								      test('confirms discard of comments with message text', () => {
 								        element._messageText = 'test';
-												Show confirmation dialog before destructively discarding draft comments

The discard confirm dialog is added alongside the delete confirm dialog
and the dialog opening/closing code is refactored to work on either. The
confirm discard dialog only appears if the draft message is savable.

Feature: Issue 6984
Change-Id: I6d88a8734fa7736f685796790e02437b10c81f00

											
										
										
											2017-10-18 13:22:43 -07:00
+								        element._handleDiscard(mockEvent);
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								        assert.isTrue(overlayStub.calledWith(element.confirmDiscardOverlay));
-												Show confirmation dialog before destructively discarding draft comments

The discard confirm dialog is added alongside the delete confirm dialog
and the dialog opening/closing code is refactored to work on either. The
confirm discard dialog only appears if the draft message is savable.

Feature: Issue 6984
Change-Id: I6d88a8734fa7736f685796790e02437b10c81f00

											
										
										
											2017-10-18 13:22:43 -07:00
+								        assert.isFalse(discardStub.called);
 								      });
-												Restore confirm discard dialog for draft comments

Draft comments with message text should have a confirm dialog when
discarded to prevent accidental data loss.

This is a regression introduced by I0dae814.

Bug: Issue 7900
Change-Id: Ibd9829ccf36a551445282e5cb0d37c1a6df46ab9

											
										
										
											2017-12-05 11:40:43 -08:00
+								      test('no confirmation for comments without message text', () => {
 								        element._messageText = '';
-												Show confirmation dialog before destructively discarding draft comments

The discard confirm dialog is added alongside the delete confirm dialog
and the dialog opening/closing code is refactored to work on either. The
confirm discard dialog only appears if the draft message is savable.

Feature: Issue 6984
Change-Id: I6d88a8734fa7736f685796790e02437b10c81f00

											
										
										
											2017-10-18 13:22:43 -07:00
+								        element._handleDiscard(mockEvent);
 								        assert.isFalse(overlayStub.called);
 								        assert.isTrue(discardStub.calledOnce);
 								      });
-												Remove draft comment from local storage upon discard

Previously, when a user discarded a draft comment, the draft was still
stored in local storage. If they tried to reply to a comment on the same
line, the previous message appeared when it shouldn't have. This change
removes drafts from local storage when they are discarded.

Bug: Issue 4361
Change-Id: Id234676972a21a879e68e754968abf7008098cf6

											
										
										
											2016-12-01 10:55:14 -08:00
+								    });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								    test('ctrl+s saves comment', done => {
 								      const stub = sinon.stub(element, 'save', () => {
-												Add ctrl+s as keyboard shortcut to save comment draft

Shortcut only functions while editing the actual text area of the
comment. This makes sense, as one should have to save each individual
comment as a draft. This also mimics the current behavior of GWT UI.

Bug: Issue 3848
Change-Id: I7037d3dbdc5dae3048fcae580ed09c41e54f0669

											
										
										
											2016-08-23 12:07:04 -07:00
+								        assert.isTrue(stub.called);
 								        stub.restore();
 								        done();
-												Report timing for updating diff comment drafts

Record the time it takes to save, update and delete comments starting
with the handlers for user corresponding interactions.

Change-Id: I9f22dc2e015fa46afcd5d531a3c0d4906e0bec89

											
										
										
											2018-05-14 12:59:23 -07:00
+								        return Promise.resolve();
-												Add ctrl+s as keyboard shortcut to save comment draft

Shortcut only functions while editing the actual text area of the
comment. This makes sense, as one should have to save each individual
comment as a draft. This also mimics the current behavior of GWT UI.

Bug: Issue 3848
Change-Id: I7037d3dbdc5dae3048fcae580ed09c41e54f0669

											
										
										
											2016-08-23 12:07:04 -07:00
+								      });
 								      element._messageText = 'is that the horse from horsing around??';
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								      element.editing = true;
 								      flushAsynchronousOperations();
-												Add ctrl+s as keyboard shortcut to save comment draft

Shortcut only functions while editing the actual text area of the
comment. This makes sense, as one should have to save each individual
comment as a draft. This also mimics the current behavior of GWT UI.

Bug: Issue 3848
Change-Id: I7037d3dbdc5dae3048fcae580ed09c41e54f0669

											
										
										
											2016-08-23 12:07:04 -07:00
+								      MockInteractions.pressAndReleaseKeyOn(
-												Guard comment textarea and overlays behind dom-if templates

Until the thread list was added, we rarely rendered a large number of
diff comments at once. A diff would add them incrementally in an
asynchronous loop, and even then, their number was reduced by being
filtered to to the given path and patch range.

Rendering all comments at once in the thread list exposed inefficiencies
in instantiating gr-diff-comments, and, for changes with many comments,
could temporarily lockup the browser.

The biggest cause of slowness in comment instantiation was the textarea
for editing. Because existing comments are not in an edit state by
default (...and because only the final comment in a thread can be edited
anyway ... assuming the user even chooses to edit ... assuming there
even is an authenticated user...) it's more efficient to put the
textarea in a dom-if until it's needed.

The overlays are also expensive but infrequently used. These are put
inside a dom-if as well.

Change-Id: I50702afe2b178221110ad3200c5e3862a7722c5d

											
										
										
											2018-04-05 10:48:03 -07:00
+								          element.textarea.$.textarea.textarea,
-												Fix errors introduced by eslint^4.0.0

The release of eslint 4 introduced some breaking changes -- a full
upgrade guide can be found here [1].

In this change, the "no-useless-escape" and "indent" rules are disabled,
"indent" being replaced with "indent-legacy" to minimize breaks due to
lint. Also, extra spaces before comments and other assorted new lint
issues are corrected.

The long-term plan is to move away from the deprecated "indent-legacy"
rule and also reenable the "no-useless-escape" rule, but for now we
want to minimize breakages and not affect PG developer velocity.

[1] http://eslint.org/docs/user-guide/migrating-to-4.0.0

Change-Id: I8044256c95e3fe3f94fa9acc7922600908f8a0f4

											
										
										
											2017-07-05 11:17:26 -07:00
+, 'ctrl'); // 'ctrl + s'
-												Add ctrl+s as keyboard shortcut to save comment draft

Shortcut only functions while editing the actual text area of the
comment. This makes sense, as one should have to save each individual
comment as a draft. This also mimics the current behavior of GWT UI.

Bug: Issue 3848
Change-Id: I7037d3dbdc5dae3048fcae580ed09c41e54f0669

											
										
										
											2016-08-23 12:07:04 -07:00
+								    });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								    test('draft saving/editing', done => {
 								      const fireStub = sinon.stub(element, 'fire');
-												Catch-all fix for merged linter errors

Bug: Issue 6179
Change-Id: I436b6dbd88e83b4d901d5446a0c7900678be157d

											
										
										
											2017-05-17 16:00:33 -07:00
+								      const cancelDebounce = sandbox.stub(element, 'cancelDebouncer');
-												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
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								      element.draft = true;
 								      MockInteractions.tap(element.$$('.edit'));
-												Cleanup of diff comment draft saving work

- Refactors the _editDraft property of gr-diff-comment to _messageText.
- Renames the gr-storage element as instantiated in gr-diff-comment from
  "localStorage" to "storage".
- The gr-storage diff comment functions are refactored to include
  "comment" in their names and to accept a location object rather than 4
  separate arguments.
- Added a comment describing the use of a promise in the _loadLocalDraft
  method of gr-diff-comment.
- Throttled the invocation of the _cleanupDrafts method of gr-storage to
  avoid potentially expensive crawls over all localStorage entries.
- Various other smaller fixes.

Bug: Issue 3787
Change-Id: Idf96051c0d56d6ce8b15f55ca2680363bd1ca805

											
										
										
											2016-05-23 13:53:10 -07:00
+								      element._messageText = 'good news, everyone!';
-												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.flushDebouncer('fire-update');
 								      element.flushDebouncer('store');
 								      assert(fireStub.calledWith('comment-update'),
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								          'comment-update should be sent');
-												Clean up comment editing UX

The removal of the 'Discard' button from comments in the editing state
complicated the UX of the 'Cancel' button a bit.

Previously:
- Discard deleted the draft completely.
- Cancel cancelled whatever edits were made, and reverted to the prior
  draft state. Cancel was also hidden on new drafts.

Currently:
- Cancel cancels whatever edits were made, and reverts to whatever edit
  was last stored.

This behavior is problematic, for a few reasons:
- Due to some vestigial code, the actual value of the comment's message
  (not just the buffer value '_messageText') was updated any time the
  draft comment was edited. This was done to prevent multiple drafts
  from being created on the same thread -- that issue was made obsolete
  by the removal of buttons from individual comments, and their
  consolidation to the thread level.
- If a user cancels a draft, then restarts it (having their text
  repopulated from localstorage), then cancels it again, the draft is
  rendered as a saved draft comment with the localstorage value, despite
  having never been saved at all.

So, with this change:
- Cancel cancels whatever edits were made.
- If a user tries to add a draft in the same place...
  - ...and the draft has been saved on the server, the textarea is
    prepopulated with the value from the comment received from the
    server.
  - ...and the draft has NOT been saved on the server, the textarea is
    rehydrated from localstorage.

This UX makes sense because...
- Case 1 occurs when a user clicks "Edit" on an existing draft comment -
  thus expecting to edit the content shown in the UI.
- Case 2 occurs when a user cancels a draft that they started
  constructing, but did not save -- thus there is no suggestion of any
  prepopulated value by the UI, _and_ the case in which a draft was
  erroneously cancelled during editing can be solved.

Bug: Issue 7709
Change-Id: Iacf9a91fbb0226aba3a518f56edd61f28c15a8ef

											
										
										
											2017-11-09 11:38:59 -08:00
+								      assert.isTrue(fireStub.calledOnce);
 								      element._messageText = 'good news, everyone!';
 								      element.flushDebouncer('fire-update');
 								      element.flushDebouncer('store');
 								      assert.isTrue(fireStub.calledOnce,
 								          'No events should fire for text editing');
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								      MockInteractions.tap(element.$$('.save'));
-												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
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								      assert.isTrue(element.disabled,
 								          'Element should be disabled when creating draft.');
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								      element._xhrPromise.then(draft => {
-												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
+								        assert(fireStub.calledWith('comment-save'),
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								            'comment-save should be sent');
-												Fix draft storage issue

Previously, there was a race condition in which erasing a draft comment
could occur prior to the updated version of the comment getting saved.
When this happened, if the user replied to the same thread, their old
draft would be pre-populated in the new reply.

This change cancels the 'store' debouncer when erasing a draft comment,
to avoid this race condition.

Bug: Issue 6141
Change-Id: I11a646acf01b1ac986c587e1e8fdb4fd7efc25b7

											
										
										
											2017-05-16 15:12:08 -07:00
+								        assert(cancelDebounce.calledWith('store'));
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
-												Establish annotation pipeline

Apply diff annotations (intraline differences and comment ranges) by
executing the annotation layers in order to each line. The diff builder
maintains an ordered array of annotation layers which are communicated
to GrDiffBuilder subclass instances. The builder also listens to each
layer for notifications that annotations have changed for some line
range and re-renders (i.e. re-applies the pipeline on DIV.contentText
elements) accordingly.

Change-Id: Iea0599d4869cafaadc0974158153a91d927913e8

											
										
										
											2016-07-14 12:31:09 -07:00
+								        assert.deepEqual(fireStub.lastCall.args[1], {
 								          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
+								            __commentSide: 'right',
-												Establish annotation pipeline

Apply diff annotations (intraline differences and comment ranges) by
executing the annotation layers in order to each line. The diff builder
maintains an ordered array of annotation layers which are communicated
to GrDiffBuilder subclass instances. The builder also listens to each
layer for notifications that annotations have changed for some line
range and re-renders (i.e. re-applies the pipeline on DIV.contentText
elements) accordingly.

Change-Id: Iea0599d4869cafaadc0974158153a91d927913e8

											
										
										
											2016-07-14 12:31:09 -07:00
+								            __draft: true,
 								            __draftID: 'temp_draft_id',
 								            id: 'baf0414d_40572e03',
 								            line: 5,
 								            message: 'saved!',
 								            path: '/path/to/file',
 								            updated: '2015-12-08 21:52:36.177000000',
-												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
+								          },
-												Establish annotation pipeline

Apply diff annotations (intraline differences and comment ranges) by
executing the annotation layers in order to each line. The diff builder
maintains an ordered array of annotation layers which are communicated
to GrDiffBuilder subclass instances. The builder also listens to each
layer for notifications that annotations have changed for some line
range and re-renders (i.e. re-applies the pipeline on DIV.contentText
elements) accordingly.

Change-Id: Iea0599d4869cafaadc0974158153a91d927913e8

											
										
										
											2016-07-14 12:31:09 -07:00
+								          patchNum: 1,
 								        });
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								        assert.isFalse(element.disabled,
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								            'Element should be enabled when done creating draft.');
-												gr-request/gr-ajax cleanup (gr-diff-comment)

Bug: Issue 3988
Change-Id: I0c100a0b77a256c1eb34f94e8fff0515add5dea1

											
										
										
											2016-05-03 15:14:57 -04:00
+								        assert.equal(draft.message, 'saved!');
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								        assert.isFalse(element.editing);
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								      }).then(() => {
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								        MockInteractions.tap(element.$$('.edit'));
-												Ranged comments integration

- gr-file-list recognizes local preferences (for hasRangedComments flag)
- gr-file-list reacts to cursor hotkey only if there is no range
  selected (currently always false).
- Remove dead code from GrDiffBuilderSideBySide, GrDiffBuilder,
  gr-diff-builder.html
- Bugfix: GrDiffBuilder.prototype.getGroupsByLineRange handles one-line
  BOTH code sections correctly. Test updated as well.
- Added utitily methods added to gr-diff-builder.html to reduce
  dependency on DOM structure and reduce amount of code copy-pasting:
  - renderLineRange, getContentByLine, etc
- For gr-diff.js and gr-diff-comment-thread.js addDraft renamed to
  addOrEditDraft because that's what it does.
- For both, addDraft method always creates a draft comment.
- Added support for ranged comments in gr-diff, gr-diff-comment-thread.
- Added mouseenter and mouseout events to gr-comment.js
- Refactored gr-comment.js to reduce code copy-paste, unify event
  payload, and to eliminate need of accessing component instance for
  patchNum. Tests updated as well.
- Refactored gr-diff.js UI data model update using gr-diff-builder.html
  utility methods to make code more readable.
- Added support for creating ranged comments to gr-diff.js.
- gr-selection-action-box now reacts to click and tap to create a 
  comment.

Change-Id: I01480a4c6f460774a8b2826915702800b3f81d25

											
										
										
											2016-06-09 16:08:04 -07:00
+								        element._messageText = 'You’ll be delivering a package to Chapek 9, ' +
 								            'a world where humans are killed on sight.';
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								        MockInteractions.tap(element.$$('.save'));
 								        assert.isTrue(element.disabled,
 								            'Element should be disabled when updating draft.');
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								        element._xhrPromise.then(draft => {
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								          assert.isFalse(element.disabled,
 								              'Element should be enabled when done updating draft.');
-												gr-request/gr-ajax cleanup (gr-diff-comment)

Bug: Issue 3988
Change-Id: I0c100a0b77a256c1eb34f94e8fff0515add5dea1

											
										
										
											2016-05-03 15:14:57 -04:00
+								          assert.equal(draft.message, 'saved!');
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								          assert.isFalse(element.editing);
-												Fix 'gr-diff-comment' test when run multiple times

The test worked fine on CI since they are run with a clean profile.
When tests were run in a normal browser profile manually, tests
'draft creation/cancelation' and 'draft saving/editing' failed
alternately because of local storage use for saving draft comments.

Since these tests do not test local storage (yet), we can just create
a stub for 'gr-storage#getDraftComment' which simulates a clean state.

Change-Id: Ibb63be4f1c395d47e0022f63d0d2ba0a7c87b137

											
										
										
											2016-06-05 12:20:11 +02:00
+								          fireStub.restore();
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								          done();
 								        });
 								      });
 								    });
-												Prevent save while disabled

The [Save] button cannot be clicked when the comment is disabled (via
`pointer-events: disabled;` in the CSS), and clicking the [Save] button
results in setting disabled to true. However, it is possible to click
save again before the style is applied. It's also possible to trigger
the button using a non-pointer-event (such as a key). With this change,
an extra check is added to the [Save] button's click handler to prevent
clicks when the component is disabled.

Bug: Issue 6972
Change-Id: I16117af31c5e7b5d7d49a025eebb690d8802b64b

											
										
										
											2017-10-24 16:34:10 -07:00
+								    test('draft prevent save when disabled', () => {
-												Report timing for updating diff comment drafts

Record the time it takes to save, update and delete comments starting
with the handlers for user corresponding interactions.

Change-Id: I9f22dc2e015fa46afcd5d531a3c0d4906e0bec89

											
										
										
											2018-05-14 12:59:23 -07:00
+								      const saveStub = sandbox.stub(element, 'save').returns(Promise.resolve());
-												Update gr-diff-comment unresolved toggle

This changes updates the unresolved toggle so that it only attempts to
save when explicitly tapped (as opposed to the value of resolved
changing on its own).

This was causing issues with comment synchronization between
gr-thread-view and diff comments, and also re-rendering the order of
comments in gr-thread-list within the dom-repeat.

This change also lets the resolved checkbox get selected via the enter
key.

Change-Id: I6065c745a0eabcf19df38f3cd6fd2c0d7e7434f3

											
										
										
											2018-03-08 17:29:09 -08:00
+								      element.showActions = true;
-												Prevent save while disabled

The [Save] button cannot be clicked when the comment is disabled (via
`pointer-events: disabled;` in the CSS), and clicking the [Save] button
results in setting disabled to true. However, it is possible to click
save again before the style is applied. It's also possible to trigger
the button using a non-pointer-event (such as a key). With this change,
an extra check is added to the [Save] button's click handler to prevent
clicks when the component is disabled.

Bug: Issue 6972
Change-Id: I16117af31c5e7b5d7d49a025eebb690d8802b64b

											
										
										
											2017-10-24 16:34:10 -07:00
+								      element.draft = true;
-												Update gr-diff-comment unresolved toggle

This changes updates the unresolved toggle so that it only attempts to
save when explicitly tapped (as opposed to the value of resolved
changing on its own).

This was causing issues with comment synchronization between
gr-thread-view and diff comments, and also re-rendering the order of
comments in gr-thread-list within the dom-repeat.

This change also lets the resolved checkbox get selected via the enter
key.

Change-Id: I6065c745a0eabcf19df38f3cd6fd2c0d7e7434f3

											
										
										
											2018-03-08 17:29:09 -08:00
+								      MockInteractions.tap(element.$.header);
-												Prevent save while disabled

The [Save] button cannot be clicked when the comment is disabled (via
`pointer-events: disabled;` in the CSS), and clicking the [Save] button
results in setting disabled to true. However, it is possible to click
save again before the style is applied. It's also possible to trigger
the button using a non-pointer-event (such as a key). With this change,
an extra check is added to the [Save] button's click handler to prevent
clicks when the component is disabled.

Bug: Issue 6972
Change-Id: I16117af31c5e7b5d7d49a025eebb690d8802b64b

											
										
										
											2017-10-24 16:34:10 -07:00
+								      MockInteractions.tap(element.$$('.edit'));
 								      element._messageText = 'good news, everyone!';
 								      element.flushDebouncer('fire-update');
 								      element.flushDebouncer('store');
 								      element.disabled = true;
 								      MockInteractions.tap(element.$$('.save'));
 								      assert.isFalse(saveStub.called);
 								      element.disabled = false;
 								      MockInteractions.tap(element.$$('.save'));
 								      assert.isTrue(saveStub.calledOnce);
 								    });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								    test('clicking on date link does not trigger nav', () => {
 								      const showStub = sinon.stub(page, 'show');
 								      const dateEl = element.$$('.date');
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								      assert.ok(dateEl);
 								      MockInteractions.tap(dateEl);
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								      const dest = window.location.pathname + '#5';
-												Draft comments initial implementation

This implements basic functionality for draft CRUD operations.

There are a few things that are TBD:
+ Layout edge cases within the diff view.
+ Reply/Done actions in threads.
+ Not allowing the user to add drafts if logged out.
+ I’m sure a few more things...

Feature: Issue 3649
Change-Id: Ia7419eecee5d5b20e73e17241990d7a7ffede0e8

											
										
										
											2015-12-02 11:40:14 -05:00
+								      assert(showStub.lastCall.calledWithExactly(dest, null, false),
 								          'Should navigate to ' + dest + ' without triggering nav');
 								      showStub.restore();
 								    });
-												Add resolvable comments checkbox

Adds the 'resolved' checkbox to the front end. Unresolved comment
threads are indicated by #fcfaa6 as background-color, whereas resolved
threads have the background #fcfad6.

Feature: Issue 4879
Change-Id: Ie1eeba61ccba559f89b707542acab2198c99b8a7

											
										
										
											2017-01-04 16:45:21 -08:00
-												Allow toggling resolved outside editing state

A recent change modified some comment editing UX. As a consequence, the
save button disabled state was erroneously based entirely on whether or
not the comment message had changed.

With this change:
- Save disabled state on a comment takes into account resolved state
- The resolved checkbox is always visible on an expanded draft comment
- When the resolved checkbox is modified on a non-`editing` draft
  comment, it is saved immediately

Bug: Issue 6023
Change-Id: I40b0b280129e5a76c13e38c97525f91a8e56482d

											
										
										
											2017-12-05 11:03:52 -08:00
+								    test('proper event fires on resolve, comment is not saved', done => {
-												Modify resolved checkbox to call save()

Previously, the resolved checkbox called _saveDraft(). Using save()
instead disables the comment while waiting for the save request to
return.

Bug: Issue 7933
Change-Id: I44ce88094b271aa46a726a75aa4eb283b29f1a35

											
										
										
											2017-12-06 11:25:30 -08:00
+								      const save = sandbox.stub(element, 'save');
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								      element.addEventListener('comment-update', e => {
-												Add resolvable comments checkbox

Adds the 'resolved' checkbox to the front end. Unresolved comment
threads are indicated by #fcfaa6 as background-color, whereas resolved
threads have the background #fcfad6.

Feature: Issue 4879
Change-Id: Ie1eeba61ccba559f89b707542acab2198c99b8a7

											
										
										
											2017-01-04 16:45:21 -08:00
+								        assert.isTrue(e.detail.comment.unresolved);
-												Allow toggling resolved outside editing state

A recent change modified some comment editing UX. As a consequence, the
save button disabled state was erroneously based entirely on whether or
not the comment message had changed.

With this change:
- Save disabled state on a comment takes into account resolved state
- The resolved checkbox is always visible on an expanded draft comment
- When the resolved checkbox is modified on a non-`editing` draft
  comment, it is saved immediately

Bug: Issue 6023
Change-Id: I40b0b280129e5a76c13e38c97525f91a8e56482d

											
										
										
											2017-12-05 11:03:52 -08:00
+								        assert.isFalse(save.called);
-												Add resolvable comments checkbox

Adds the 'resolved' checkbox to the front end. Unresolved comment
threads are indicated by #fcfaa6 as background-color, whereas resolved
threads have the background #fcfad6.

Feature: Issue 4879
Change-Id: Ie1eeba61ccba559f89b707542acab2198c99b8a7

											
										
										
											2017-01-04 16:45:21 -08:00
+								        done();
 								      });
 								      MockInteractions.tap(element.$$('.resolve input'));
 								    });
-												ES6ify /gr-diff-comment/*

Bug: Issue 6179
Change-Id: Id103711e6a7ca24785a301dbb8341bb0c8f63617

											
										
										
											2017-05-16 13:50:27 -07:00
+								    test('resolved comment state indicated by checkbox', () => {
-												Modify resolved checkbox to call save()

Previously, the resolved checkbox called _saveDraft(). Using save()
instead disables the comment while waiting for the save request to
return.

Bug: Issue 7933
Change-Id: I44ce88094b271aa46a726a75aa4eb283b29f1a35

											
										
										
											2017-12-06 11:25:30 -08:00
+								      sandbox.stub(element, 'save');
-												Add resolvable comments checkbox

Adds the 'resolved' checkbox to the front end. Unresolved comment
threads are indicated by #fcfaa6 as background-color, whereas resolved
threads have the background #fcfad6.

Feature: Issue 4879
Change-Id: Ie1eeba61ccba559f89b707542acab2198c99b8a7

											
										
										
											2017-01-04 16:45:21 -08:00
+								      element.comment = {unresolved: false};
 								      assert.isTrue(element.$$('.resolve input').checked);
 								      element.comment = {unresolved: true};
 								      assert.isFalse(element.$$('.resolve input').checked);
 								    });
-												Show toast messages for storing diff comment drafts

With this change, toast messages show when diff comments are being saved
and notify when saving is complete, even when the diff view is no-longer
loaded. This signal is intended to encourage users to write diff
comments and feel free to navigate away to view other parts of a change.

With this change, new toast messages are able to replace existing toast
messages.

Feature: Issue 6970
Change-Id: I5973673d85c73b14794cb5e5b21327dd0c27ec1d

											
										
										
											2017-09-12 17:01:42 -07:00
-												Update gr-diff-comment unresolved toggle

This changes updates the unresolved toggle so that it only attempts to
save when explicitly tapped (as opposed to the value of resolved
changing on its own).

This was causing issues with comment synchronization between
gr-thread-view and diff comments, and also re-rendering the order of
comments in gr-thread-list within the dom-repeat.

This change also lets the resolved checkbox get selected via the enter
key.

Change-Id: I6065c745a0eabcf19df38f3cd6fd2c0d7e7434f3

											
										
										
											2018-03-08 17:29:09 -08:00
+								    test('resolved checkbox saves with tap when !editing', () => {
-												Allow toggling resolved outside editing state

A recent change modified some comment editing UX. As a consequence, the
save button disabled state was erroneously based entirely on whether or
not the comment message had changed.

With this change:
- Save disabled state on a comment takes into account resolved state
- The resolved checkbox is always visible on an expanded draft comment
- When the resolved checkbox is modified on a non-`editing` draft
  comment, it is saved immediately

Bug: Issue 6023
Change-Id: I40b0b280129e5a76c13e38c97525f91a8e56482d

											
										
										
											2017-12-05 11:03:52 -08:00
+								      element.editing = false;
-												Modify resolved checkbox to call save()

Previously, the resolved checkbox called _saveDraft(). Using save()
instead disables the comment while waiting for the save request to
return.

Bug: Issue 7933
Change-Id: I44ce88094b271aa46a726a75aa4eb283b29f1a35

											
										
										
											2017-12-06 11:25:30 -08:00
+								      const save = sandbox.stub(element, 'save');
-												Allow toggling resolved outside editing state

A recent change modified some comment editing UX. As a consequence, the
save button disabled state was erroneously based entirely on whether or
not the comment message had changed.

With this change:
- Save disabled state on a comment takes into account resolved state
- The resolved checkbox is always visible on an expanded draft comment
- When the resolved checkbox is modified on a non-`editing` draft
  comment, it is saved immediately

Bug: Issue 6023
Change-Id: I40b0b280129e5a76c13e38c97525f91a8e56482d

											
										
										
											2017-12-05 11:03:52 -08:00
 								      element.comment = {unresolved: false};
 								      assert.isTrue(element.$$('.resolve input').checked);
 								      element.comment = {unresolved: true};
 								      assert.isFalse(element.$$('.resolve input').checked);
-												Update gr-diff-comment unresolved toggle

This changes updates the unresolved toggle so that it only attempts to
save when explicitly tapped (as opposed to the value of resolved
changing on its own).

This was causing issues with comment synchronization between
gr-thread-view and diff comments, and also re-rendering the order of
comments in gr-thread-list within the dom-repeat.

This change also lets the resolved checkbox get selected via the enter
key.

Change-Id: I6065c745a0eabcf19df38f3cd6fd2c0d7e7434f3

											
										
										
											2018-03-08 17:29:09 -08:00
+								      assert.isFalse(save.called);
 								      MockInteractions.tap(element.$.resolvedCheckbox);
 								      assert.isTrue(element.$$('.resolve input').checked);
-												Allow toggling resolved outside editing state

A recent change modified some comment editing UX. As a consequence, the
save button disabled state was erroneously based entirely on whether or
not the comment message had changed.

With this change:
- Save disabled state on a comment takes into account resolved state
- The resolved checkbox is always visible on an expanded draft comment
- When the resolved checkbox is modified on a non-`editing` draft
  comment, it is saved immediately

Bug: Issue 6023
Change-Id: I40b0b280129e5a76c13e38c97525f91a8e56482d

											
										
										
											2017-12-05 11:03:52 -08:00
+								      assert.isTrue(save.called);
 								    });
-												Show toast messages for storing diff comment drafts

With this change, toast messages show when diff comments are being saved
and notify when saving is complete, even when the diff view is no-longer
loaded. This signal is intended to encourage users to write diff
comments and feel free to navigate away to view other parts of a change.

With this change, new toast messages are able to replace existing toast
messages.

Feature: Issue 6970
Change-Id: I5973673d85c73b14794cb5e5b21327dd0c27ec1d

											
										
										
											2017-09-12 17:01:42 -07:00
+								    suite('draft saving messages', () => {
 								      test('_getSavingMessage', () => {
 								        assert.equal(element._getSavingMessage(0), 'All changes saved');
 								        assert.equal(element._getSavingMessage(1), 'Saving 1 draft...');
 								        assert.equal(element._getSavingMessage(2), 'Saving 2 drafts...');
 								        assert.equal(element._getSavingMessage(3), 'Saving 3 drafts...');
 								      });
 								      test('_show{Start,End}Request', () => {
 								        const updateStub = sandbox.stub(element, '_updateRequestToast');
-												Only erase unsaved drafts after save request succeeds

Unsaved diff drafts are kept in localstorage so they are not lost if
they do not get saved (for example, if the browser crashes). However,
this stored copy of the comment is cleared when the save request is
started, not after it succeeds. As such, if the save request fails (for
example, if the user credentials are invalid), the comment can be truly
lost.

With this change, the localstorage copy is only cleared after save
success. If the request fails, it allows the error message to appear
rather than showing a misleading "All comments saved" toast.

Bug: issue 7289
Change-Id: Id5c8144ecccec50de35f83af616b4e4915b62b5c

											
										
										
											2017-10-26 14:11:24 -07:00
+								        element._numPendingDraftRequests.number = 1;
-												Show toast messages for storing diff comment drafts

With this change, toast messages show when diff comments are being saved
and notify when saving is complete, even when the diff view is no-longer
loaded. This signal is intended to encourage users to write diff
comments and feel free to navigate away to view other parts of a change.

With this change, new toast messages are able to replace existing toast
messages.

Feature: Issue 6970
Change-Id: I5973673d85c73b14794cb5e5b21327dd0c27ec1d

											
										
										
											2017-09-12 17:01:42 -07:00
 								        element._showStartRequest();
 								        assert.isTrue(updateStub.calledOnce);
 								        assert.equal(updateStub.lastCall.args[0], 2);
-												Only erase unsaved drafts after save request succeeds

Unsaved diff drafts are kept in localstorage so they are not lost if
they do not get saved (for example, if the browser crashes). However,
this stored copy of the comment is cleared when the save request is
started, not after it succeeds. As such, if the save request fails (for
example, if the user credentials are invalid), the comment can be truly
lost.

With this change, the localstorage copy is only cleared after save
success. If the request fails, it allows the error message to appear
rather than showing a misleading "All comments saved" toast.

Bug: issue 7289
Change-Id: Id5c8144ecccec50de35f83af616b4e4915b62b5c

											
										
										
											2017-10-26 14:11:24 -07:00
+								        assert.equal(element._numPendingDraftRequests.number, 2);
-												Show toast messages for storing diff comment drafts

With this change, toast messages show when diff comments are being saved
and notify when saving is complete, even when the diff view is no-longer
loaded. This signal is intended to encourage users to write diff
comments and feel free to navigate away to view other parts of a change.

With this change, new toast messages are able to replace existing toast
messages.

Feature: Issue 6970
Change-Id: I5973673d85c73b14794cb5e5b21327dd0c27ec1d

											
										
										
											2017-09-12 17:01:42 -07:00
 								        element._showEndRequest();
 								        assert.isTrue(updateStub.calledTwice);
 								        assert.equal(updateStub.lastCall.args[0], 1);
-												Only erase unsaved drafts after save request succeeds

Unsaved diff drafts are kept in localstorage so they are not lost if
they do not get saved (for example, if the browser crashes). However,
this stored copy of the comment is cleared when the save request is
started, not after it succeeds. As such, if the save request fails (for
example, if the user credentials are invalid), the comment can be truly
lost.

With this change, the localstorage copy is only cleared after save
success. If the request fails, it allows the error message to appear
rather than showing a misleading "All comments saved" toast.

Bug: issue 7289
Change-Id: Id5c8144ecccec50de35f83af616b4e4915b62b5c

											
										
										
											2017-10-26 14:11:24 -07:00
+								        assert.equal(element._numPendingDraftRequests.number, 1);
-												Show toast messages for storing diff comment drafts

With this change, toast messages show when diff comments are being saved
and notify when saving is complete, even when the diff view is no-longer
loaded. This signal is intended to encourage users to write diff
comments and feel free to navigate away to view other parts of a change.

With this change, new toast messages are able to replace existing toast
messages.

Feature: Issue 6970
Change-Id: I5973673d85c73b14794cb5e5b21327dd0c27ec1d

											
										
										
											2017-09-12 17:01:42 -07:00
 								        element._showEndRequest();
 								        assert.isTrue(updateStub.calledThrice);
 								        assert.equal(updateStub.lastCall.args[0], 0);
-												Only erase unsaved drafts after save request succeeds

Unsaved diff drafts are kept in localstorage so they are not lost if
they do not get saved (for example, if the browser crashes). However,
this stored copy of the comment is cleared when the save request is
started, not after it succeeds. As such, if the save request fails (for
example, if the user credentials are invalid), the comment can be truly
lost.

With this change, the localstorage copy is only cleared after save
success. If the request fails, it allows the error message to appear
rather than showing a misleading "All comments saved" toast.

Bug: issue 7289
Change-Id: Id5c8144ecccec50de35f83af616b4e4915b62b5c

											
										
										
											2017-10-26 14:11:24 -07:00
+								        assert.equal(element._numPendingDraftRequests.number, 0);
-												Show toast messages for storing diff comment drafts

With this change, toast messages show when diff comments are being saved
and notify when saving is complete, even when the diff view is no-longer
loaded. This signal is intended to encourage users to write diff
comments and feel free to navigate away to view other parts of a change.

With this change, new toast messages are able to replace existing toast
messages.

Feature: Issue 6970
Change-Id: I5973673d85c73b14794cb5e5b21327dd0c27ec1d

											
										
										
											2017-09-12 17:01:42 -07:00
+								      });
 								    });
-												Show comment saving progress indicator inside comments themselves

Bug: Issue 7596
Change-Id: I194bce633c8d746c24f71fc7f4bbdf2b87e5b883

											
										
										
											2017-11-02 18:17:52 -07:00
-												Clean up comment editing UX

The removal of the 'Discard' button from comments in the editing state
complicated the UX of the 'Cancel' button a bit.

Previously:
- Discard deleted the draft completely.
- Cancel cancelled whatever edits were made, and reverted to the prior
  draft state. Cancel was also hidden on new drafts.

Currently:
- Cancel cancels whatever edits were made, and reverts to whatever edit
  was last stored.

This behavior is problematic, for a few reasons:
- Due to some vestigial code, the actual value of the comment's message
  (not just the buffer value '_messageText') was updated any time the
  draft comment was edited. This was done to prevent multiple drafts
  from being created on the same thread -- that issue was made obsolete
  by the removal of buttons from individual comments, and their
  consolidation to the thread level.
- If a user cancels a draft, then restarts it (having their text
  repopulated from localstorage), then cancels it again, the draft is
  rendered as a saved draft comment with the localstorage value, despite
  having never been saved at all.

So, with this change:
- Cancel cancels whatever edits were made.
- If a user tries to add a draft in the same place...
  - ...and the draft has been saved on the server, the textarea is
    prepopulated with the value from the comment received from the
    server.
  - ...and the draft has NOT been saved on the server, the textarea is
    rehydrated from localstorage.

This UX makes sense because...
- Case 1 occurs when a user clicks "Edit" on an existing draft comment -
  thus expecting to edit the content shown in the UI.
- Case 2 occurs when a user cancels a draft that they started
  constructing, but did not save -- thus there is no suggestion of any
  prepopulated value by the UI, _and_ the case in which a draft was
  erroneously cancelled during editing can be solved.

Bug: Issue 7709
Change-Id: Iacf9a91fbb0226aba3a518f56edd61f28c15a8ef

											
										
										
											2017-11-09 11:38:59 -08:00
+								    test('cancelling an unsaved draft discards, persists in storage', () => {
 								      const discardSpy = sandbox.spy(element, '_fireDiscard');
 								      const storeStub = sandbox.stub(element.$.storage, 'setDraftComment');
 								      const eraseStub = sandbox.stub(element.$.storage, 'eraseDraftComment');
 								      element._messageText = 'test text';
 								      flushAsynchronousOperations();
 								      element.flushDebouncer('store');
 								      assert.isTrue(storeStub.called);
 								      assert.equal(storeStub.lastCall.args[1], 'test text');
 								      element._handleCancel({preventDefault: () => {}});
 								      assert.isTrue(discardSpy.called);
 								      assert.isFalse(eraseStub.called);
 								    });
 								    test('cancelling edit on a saved draft does not store', () => {
 								      element.comment.id = 'foo';
 								      const discardSpy = sandbox.spy(element, '_fireDiscard');
 								      const storeStub = sandbox.stub(element.$.storage, 'setDraftComment');
 								      element._messageText = 'test text';
 								      flushAsynchronousOperations();
 								      element.flushDebouncer('store');
 								      assert.isFalse(storeStub.called);
 								      element._handleCancel({preventDefault: () => {}});
 								      assert.isTrue(discardSpy.called);
 								    });
-												Delete draft comment when saved with empty text

Recently, the comment editing UX was changed (the discard button was
removed from the editing view). This (obviously) made it impossible to
discard a draft comment whilst editing it.

Editing a comment, clearing the text, and saving now removes the
comment.

Bug: Issue 7832
Change-Id: I0dae814b9ce2e7a5b57530f839c708e59c215341

											
										
										
											2017-11-27 16:13:06 -08:00
 								    test('deleting text from saved draft and saving deletes the draft', () => {
 								      element.comment = {id: 'foo', message: 'test'};
 								      element._messageText = '';
 								      const discardStub = sandbox.stub(element, '_discardDraft');
 								      element.save();
 								      assert.isTrue(discardStub.called);
 								    });
-												[PolyGerrit] Render (read-only) comments and column width ruler.

Also some small additional changes as well:
+ Correct some :host selectors that were causing issues when Shadow DOM
  was used instead of Shady DOM.
+ Two of the same revisions should not be shown in side-by-side view.
  When two are specified via the url as /N..N/ redirect to /N/.
+ Added header to the diff view to give context and allow the user to
  go back to the top-level change.

Feature: Issue 3676
Feature: Issue 3648
Feature: Issue 3649
Change-Id: Ib39bb7cb2eab26740f80971d4e00d579a2e08b0b

											
										
										
											2015-11-18 16:31:18 -05:00
+								  });
 								</script>