Add warning for multipolygon members with no set role (close #5851)

modules/validations/index.js

@@ -5,6 +5,7 @@ export { validationDisconnectedWay } from './disconnected_way';
 export { validationGenericName } from './generic_name';
 export { validationManyDeletions } from './many_deletions';
 export { validationMaprules } from './maprules';
+export { validationMissingRole } from './missing_role';
 export { validationMissingTag } from './missing_tag';
 export { validationOldMultipolygon } from './old_multipolygon';
 export { validationTagSuggestsArea } from './tag_suggests_area';

modules/validations/missing_role.js

@@ -0,0 +1,84 @@
+import { actionChangeMember, actionDeleteMember } from '../actions';
+import { t } from '../util/locale';
+import { utilDisplayLabel } from '../util';
+import { validationIssue, validationIssueFix } from '../core/validator';
+
+
+export function validationMissingRole() {
+    var type = 'missing_role';
+
+    var validation = function(entity, context) {
+
+        var issues = [];
+        if (entity.type === 'way') {
+            context.graph().parentRelations(entity).forEach(function(relation) {
+                if (!relation.isMultipolygon()) {
+                    return;
+                }
+                var member = relation.memberById(entity.id);
+                if (member && isMissingRole(member)) {
+                    issues.push(makeIssue(entity, relation, member, context));
+                }
+            });
+        } else if (entity.type === 'relation' && entity.isMultipolygon()) {
+            entity.indexedMembers().forEach(function(member) {
+                var way = context.hasEntity(member.id);
+                if (way && isMissingRole(member)) {
+                    issues.push(makeIssue(way, entity, member, context));
+                }
+            });
+        }
+
+        return issues;
+    };
+
+    function isMissingRole(member) {
+        return !member.role || !member.role.trim().length;
+    }
+
+    function makeIssue(way, relation, member, context) {
+        return new validationIssue({
+            type: type,
+            severity: 'warning',
+            message: t('issues.missing_role.message', {
+                member: utilDisplayLabel(way, context),
+                relation: utilDisplayLabel(relation, context),
+            }),
+            tooltip: t('issues.missing_role.multipolygon.tip'),
+            entities: [relation, way],
+            info: {member: member},
+            fixes: [
+                makeAddRoleFix('inner', context),
+                makeAddRoleFix('outer', context),
+                new validationIssueFix({
+                    icon: 'iD-operation-delete',
+                    title: t('issues.fix.remove_from_relation.title'),
+                    onClick: function() {
+                        context.perform(
+                            actionDeleteMember(this.issue.entities[0].id, this.issue.info.member.index),
+                            t('operations.delete_member.annotation')
+                        );
+                    }
+                })
+            ]
+        });
+    }
+
+    function makeAddRoleFix(role, context) {
+        return new validationIssueFix({
+            title: t('issues.fix.set_as_' + role + '.title'),
+            onClick: function() {
+                var oldMember = this.issue.info.member;
+                var member = { id: this.issue.entities[1].id, type: oldMember.type, role: role };
+                context.perform(
+                    actionChangeMember(this.issue.entities[0].id, member, oldMember.index),
+                    t('operations.change_role.annotation')
+                );
+            }
+        });
+    }
+
+    validation.type = type;
+
+    return validation;
+}