blob: 4ad99d5dbe138448adbf0682826cf9f19a23afd6 [file] [log] [blame]
/**
* @license
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import '../../../styles/shared-styles';
import '../../plugins/gr-endpoint-decorator/gr-endpoint-decorator';
import '../../plugins/gr-endpoint-param/gr-endpoint-param';
import '../../plugins/gr-endpoint-slot/gr-endpoint-slot';
import {flush} from '@polymer/polymer/lib/legacy/polymer.dom';
import {GestureEventListeners} from '@polymer/polymer/lib/mixins/gesture-event-listeners';
import {LegacyElementMixin} from '@polymer/polymer/lib/legacy/legacy-element-mixin';
import {PolymerElement} from '@polymer/polymer/polymer-element';
import {htmlTemplate} from './gr-related-changes-list_html';
import {GerritNav} from '../../core/gr-navigation/gr-navigation';
import {ChangeStatus} from '../../../constants/constants';
import {changeIsOpen, getRevisionKey} from '../../../utils/change-util';
import {getPluginEndpoints} from '../../shared/gr-js-api-interface/gr-plugin-endpoints';
import {customElement, observe, property} from '@polymer/decorators';
import {
ChangeId,
ChangeInfo,
CommitId,
NumericChangeId,
PatchSetNum,
RelatedChangeAndCommitInfo,
RelatedChangesInfo,
RepoName,
SubmittedTogetherInfo,
} from '../../../types/common';
import {appContext} from '../../../services/app-context';
import {pluralize} from '../../../utils/string-util';
import {ParsedChangeInfo} from '../../../types/types';
function getEmptySubmitTogetherInfo(): SubmittedTogetherInfo {
return {changes: [], non_visible_changes: 0};
}
function isChangeInfo(
x: ChangeInfo | RelatedChangeAndCommitInfo
): x is ChangeInfo {
return (x as ChangeInfo)._number !== undefined;
}
@customElement('gr-related-changes-list')
export class GrRelatedChangesList extends GestureEventListeners(
LegacyElementMixin(PolymerElement)
) {
static get template() {
return htmlTemplate;
}
/**
* Fired when a new section is loaded so that the change view can determine
* a show more button is needed, sometimes before all the sections finish
* loading.
*
* @event new-section-loaded
*/
@property({type: Object})
change?: ParsedChangeInfo;
@property({type: Boolean, notify: true})
hasParent = false;
@property({type: String})
patchNum?: PatchSetNum;
@property({type: Boolean, reflectToAttribute: true})
hidden = false;
@property({type: Boolean, notify: true})
loading?: boolean;
@property({type: Boolean})
mergeable?: boolean;
@property({
type: Array,
computed:
'_computeConnectedRevisions(change, patchNum, ' +
'_relatedResponse.changes)',
})
_connectedRevisions?: CommitId[];
@property({type: Object})
_relatedResponse: RelatedChangesInfo = {changes: []};
@property({type: Object})
_submittedTogether?: SubmittedTogetherInfo = getEmptySubmitTogetherInfo();
@property({type: Array})
_conflicts: ChangeInfo[] = [];
@property({type: Array})
_cherryPicks: ChangeInfo[] = [];
@property({type: Array})
_sameTopic?: ChangeInfo[] = [];
private readonly restApiService = appContext.restApiService;
clear() {
this.loading = true;
this.hidden = true;
this._relatedResponse = {changes: []};
this._submittedTogether = getEmptySubmitTogetherInfo();
this._conflicts = [];
this._cherryPicks = [];
this._sameTopic = [];
}
reload() {
if (!this.change || !this.patchNum) {
return Promise.resolve();
}
const change = this.change;
this.loading = true;
const promises: Array<Promise<void>> = [
this.restApiService
.getRelatedChanges(change._number, this.patchNum)
.then(response => {
if (!response) {
throw new Error('getRelatedChanges returned undefined response');
}
this._relatedResponse = response;
this._fireReloadEvent();
this.hasParent = this._calculateHasParent(
change.change_id,
response.changes
);
}),
this.restApiService
.getChangesSubmittedTogether(change._number)
.then(response => {
this._submittedTogether = response;
this._fireReloadEvent();
}),
this.restApiService
.getChangeCherryPicks(change.project, change.change_id, change._number)
.then(response => {
this._cherryPicks = response || [];
this._fireReloadEvent();
}),
];
// Get conflicts if change is open and is mergeable.
if (changeIsOpen(change) && this.mergeable) {
promises.push(
this.restApiService
.getChangeConflicts(change._number)
.then(response => {
// Because the server doesn't always return a response and the
// template expects an array, always return an array.
this._conflicts = response ? response : [];
this._fireReloadEvent();
})
);
}
promises.push(
this._getServerConfig().then(config => {
if (change.topic) {
if (!config) {
throw new Error('_getServerConfig returned undefined ');
}
if (!config.change.submit_whole_topic) {
return this.restApiService
.getChangesWithSameTopic(change.topic, change._number)
.then(response => {
this._sameTopic = response;
});
}
}
this._sameTopic = [];
return Promise.resolve();
})
);
return Promise.all(promises).then(() => {
this.loading = false;
});
}
_fireReloadEvent() {
// The listener on the change computes height of the related changes
// section, so they have to be rendered first, and inside a dom-repeat,
// that requires a flush.
flush();
this.dispatchEvent(new CustomEvent('new-section-loaded'));
}
/**
* Determines whether or not the given change has a parent change. If there
* is a relation chain, and the change id is not the last item of the
* relation chain, there is a parent.
*/
_calculateHasParent(
currentChangeId: ChangeId,
relatedChanges: RelatedChangeAndCommitInfo[]
) {
return (
relatedChanges.length > 0 &&
relatedChanges[relatedChanges.length - 1].change_id !== currentChangeId
);
}
_getServerConfig() {
return this.restApiService.getConfig();
}
_computeChangeURL(
changeNum: NumericChangeId,
project: RepoName,
patchNum?: PatchSetNum
) {
return GerritNav.getUrlForChangeById(changeNum, project, patchNum);
}
/**
* Do the given objects describe the same change? Compares the changes by
* their numbers.
*/
_changesEqual(
a: ChangeInfo | RelatedChangeAndCommitInfo,
b: ChangeInfo | RelatedChangeAndCommitInfo
) {
const aNum = this._getChangeNumber(a);
const bNum = this._getChangeNumber(b);
return aNum === bNum;
}
/**
* Get the change number from either a ChangeInfo (such as those included in
* SubmittedTogetherInfo responses) or get the change number from a
* RelatedChangeAndCommitInfo (such as those included in a
* RelatedChangesInfo response).
*/
_getChangeNumber(change?: ChangeInfo | RelatedChangeAndCommitInfo) {
// Default to 0 if change property is not defined.
if (!change) return 0;
if (isChangeInfo(change)) {
return change._number;
}
return change._change_number;
}
_computeLinkClass(change: ParsedChangeInfo) {
const statuses = [];
if (change.status === ChangeStatus.ABANDONED) {
statuses.push('strikethrough');
}
if (change.submittable) {
statuses.push('submittable');
}
return statuses.join(' ');
}
_computeChangeStatusClass(change: RelatedChangeAndCommitInfo) {
const classes = ['status'];
if (change._revision_number !== change._current_revision_number) {
classes.push('notCurrent');
} else if (this._isIndirectAncestor(change)) {
classes.push('indirectAncestor');
} else if (change.submittable) {
classes.push('submittable');
} else if (change.status === ChangeStatus.NEW) {
classes.push('hidden');
}
return classes.join(' ');
}
_computeChangeStatus(change: RelatedChangeAndCommitInfo) {
switch (change.status) {
case ChangeStatus.MERGED:
return 'Merged';
case ChangeStatus.ABANDONED:
return 'Abandoned';
}
if (change._revision_number !== change._current_revision_number) {
return 'Not current';
} else if (this._isIndirectAncestor(change)) {
return 'Indirect ancestor';
} else if (change.submittable) {
return 'Submittable';
}
return '';
}
/** @override */
attached() {
super.attached();
// We listen to `new-section-loaded` events to allow plugins to trigger
// visibility computations, if their content or visibility changed.
this.addEventListener('new-section-loaded', () =>
this._handleNewSectionLoaded()
);
}
_handleNewSectionLoaded() {
// A plugin sent a `new-section-loaded` event, so its visibility likely
// changed. Hence, we update our visibility if needed.
this._resultsChanged(
this._relatedResponse,
this._submittedTogether,
this._conflicts,
this._cherryPicks,
this._sameTopic
);
}
@observe(
'_relatedResponse',
'_submittedTogether',
'_conflicts',
'_cherryPicks',
'_sameTopic'
)
_resultsChanged(
related: RelatedChangesInfo,
submittedTogether: SubmittedTogetherInfo | undefined,
conflicts: ChangeInfo[],
cherryPicks: ChangeInfo[],
sameTopic?: ChangeInfo[]
) {
if (!submittedTogether || !sameTopic) {
return;
}
const submittedTogetherChangesCount =
(submittedTogether.changes || []).length +
(submittedTogether.non_visible_changes || 0);
const results = [
related && related.changes,
// If there are either visible or non-visible changes, we need a
// non-empty list to fire the event and set visibility.
submittedTogetherChangesCount ? [{}] : [],
conflicts,
cherryPicks,
sameTopic,
];
for (let i = 0; i < results.length; i++) {
if (results[i] && results[i].length > 0) {
this.hidden = false;
this.dispatchEvent(
new CustomEvent('update', {
composed: true,
bubbles: false,
})
);
return;
}
}
this._computeHidden();
}
_computeHidden() {
// None of the built-in change lists had elements. So all of them are
// hidden. But since plugins might have injected visible content, we need
// to check for that and stay visible if we find any such visible content.
// (We consider plugins visible except if it's main element has the hidden
// attribute set to true.)
const plugins = getPluginEndpoints().getDetails('related-changes-section');
this.hidden = !plugins.some(
plugin =>
!plugin.domHook ||
plugin.domHook.getAllAttached().some(instance => !instance.hidden)
);
}
_isIndirectAncestor(change: RelatedChangeAndCommitInfo) {
return (
this._connectedRevisions &&
!this._connectedRevisions.includes(change.commit.commit)
);
}
_computeConnectedRevisions(
change?: ParsedChangeInfo,
patchNum?: PatchSetNum,
relatedChanges?: RelatedChangeAndCommitInfo[]
) {
if (!patchNum || !relatedChanges || !change) {
return [];
}
const connected: CommitId[] = [];
const changeRevision = getRevisionKey(change, patchNum);
const commits = relatedChanges.map(c => c.commit);
let pos = commits.length - 1;
while (pos >= 0) {
const commit: CommitId = commits[pos].commit;
connected.push(commit);
// TODO(TS): Ensure that both (commit and changeRevision) are string and use === instead
// eslint-disable-next-line eqeqeq
if (commit == changeRevision) {
break;
}
pos--;
}
while (pos >= 0) {
for (let i = 0; i < commits[pos].parents.length; i++) {
if (connected.includes(commits[pos].parents[i].commit)) {
connected.push(commits[pos].commit);
break;
}
}
--pos;
}
return connected;
}
_computeSubmittedTogetherClass(submittedTogether?: SubmittedTogetherInfo) {
if (
!submittedTogether ||
(submittedTogether.changes.length === 0 &&
!submittedTogether.non_visible_changes)
) {
return 'hidden';
}
return '';
}
_computeNonVisibleChangesNote(n: number) {
return `(+ ${pluralize(n, 'non-visible change')})`;
}
}
declare global {
interface HTMLElementTagNameMap {
'gr-related-changes-list': GrRelatedChangesList;
}
}