Update issue tooltips and messages

modules/validations/crossing_ways.js

@@ -223,28 +223,34 @@ export function validationHighwayCrossingOtherWays(context) {
                 var crossing = crosses[j];
 
                 // use the entities with the tags that define the feature type
-                var entities = _map(crossing.ways, function(way) {
+                var entities = crossing.ways.sort(function(entity1, entity2) {
+                    var type1 = getFeatureTypeForCrossingCheck(entity1, graph);
+                    var type2 = getFeatureTypeForCrossingCheck(entity2, graph);
+                    if (type1 === type2) {
+                        return utilDisplayLabel(entity1, context) > utilDisplayLabel(entity2, context);
+                    } else if (type1 === 'water') {
+                        return true;
+                    } else if (type2 === 'water') {
+                        return false;
+                    }
+                    return type1 < type2;
+                });
+                entities = _map(entities, function(way) {
                     return getFeatureWithFeatureTypeTagsForWay(way, graph);
                 });
-                entities = entities.sort(function(entity1, entity2) {
-                    return utilDisplayLabel(entity1, context) > utilDisplayLabel(entity2, context);
-                });
 
-                var crossingTypeID = crossing.featureTypes.sort().join('-') + '_crossing';
+                var crossingTypeID = crossing.featureTypes.sort().join('-');
 
-                var messageDict = {};
-                messageDict[crossing.featureTypes[0]] = utilDisplayLabel(entities[0], context);
-                var key2 = crossing.featureTypes[1];
-                if (crossing.featureTypes[0] === crossing.featureTypes[1]) {
-                    key2 += '2';
-                }
-                messageDict[key2] = utilDisplayLabel(entities[1], context);
+                var messageDict = {
+                    feature: utilDisplayLabel(entities[0], context),
+                    feature2: utilDisplayLabel(entities[1], context)
+                };
 
                 issues.push(new validationIssue({
                     type: ValidationIssueType.crossing_ways,
                     severity: ValidationIssueSeverity.warning,
-                    message: t('issues.'+crossingTypeID+'.message', messageDict),
-                    tooltip: t('issues.'+crossingTypeID+'.tooltip'),
+                    message: t('issues.crossing_ways.message', messageDict),
+                    tooltip: t('issues.crossing_ways.'+crossingTypeID+'.tip'),
                     entities: entities,
                     info: {'ways': crossing.ways},
                     coordinates: crossing.cross_point,

modules/validations/deprecated_tag.js

@@ -31,7 +31,7 @@ export function validationDeprecatedTag(context) {
                         type: ValidationIssueType.deprecated_tags,
                         severity: ValidationIssueSeverity.warning,
                         message: t('issues.deprecated_tags.message', { feature: featureLabel, tags: tagsLabel }),
-                        tooltip: t('issues.deprecated_tags.tooltip'),
+                        tooltip: t('issues.deprecated_tags.tip'),
                         entities: [change],
                         hash: tagsLabel,
                         info: {

modules/validations/disconnected_highway.js

@@ -40,7 +40,7 @@ export function validationDisconnectedHighway(context) {
                     type: ValidationIssueType.disconnected_highway,
                     severity: ValidationIssueSeverity.warning,
                     message: t('issues.disconnected_highway.message', {highway: entityLabel}),
-                    tooltip: t('issues.disconnected_highway.tooltip'),
+                    tooltip: t('issues.disconnected_highway.tip'),
                     entities: [entity],
                 }));
             }

modules/validations/generic_name.js

@@ -56,7 +56,7 @@ export function validationGenericName(context) {
                     type: ValidationIssueType.generic_name,
                     severity: ValidationIssueSeverity.warning,
                     message: t('issues.generic_name.message', {feature: preset.name(), name: generic}),
-                    tooltip: t('issues.generic_name.tooltip'),
+                    tooltip: t('issues.generic_name.tip'),
                     entities: [change],
                     fixes: [
                         new validationIssueFix({

modules/validations/highway_almost_junction.js

@@ -152,7 +152,7 @@ export function validationHighwayAlmostJunction(context) {
                         highway: utilDisplayLabel(endHighway, context),
                         highway2: utilDisplayLabel(edgeHighway, context)
                     }),
-                    tooltip: t('issues.highway_almost_junction.tooltip'),
+                    tooltip: t('issues.highway_almost_junction.tip'),
                     entities: [endHighway, node, edgeHighway],
                     coordinates: extendableNodes[j].node.loc,
                     info: {

modules/validations/issue_manager.js

@@ -48,16 +48,17 @@ export function IssueManager(context) {
 
         var changes = context.history().changes();
         var entitiesToCheck = changes.created.concat(changes.modified);
+        var graph = context.graph();
         entitiesToCheck = _uniq(_flattenDeep(_map(entitiesToCheck, function(entity) {
             var entities = [entity];
             if (entity.type === 'node') {
                 // validate ways if their nodes have changed
-                entities = entities.concat(context.graph().parentWays(entity));
+                entities = entities.concat(graph.parentWays(entity));
             }
             entities = _map(entities, function(entity) {
                 if (entity.type !== 'relation') {
                     // validate relations if their geometries have changed
-                    return [entity].concat(context.graph().parentRelations(entity));
+                    return [entity].concat(graph.parentRelations(entity));
                 }
                 return entity;
             });

modules/validations/missing_tag.js

@@ -33,21 +33,21 @@ export function validationMissingTag(context) {
                     type: ValidationIssueType.missing_tag,
                     severity: ValidationIssueSeverity.error,
                     message: t('issues.untagged_feature.message', {feature: entityLabel}),
-                    tooltip: t('issues.untagged_feature.tooltip'),
+                    tooltip: t('issues.untagged_feature.tip'),
                     entities: [change],
                     fixes: [
+                        new validationIssueFix({
+                            title: t('issues.fix.select_preset.title'),
+                            action: function() {
+                                context.ui().sidebar.showPresetList();
+                            }
+                        }),
                         new validationIssueFix({
                             title: t('issues.fix.delete_feature.title'),
                             action: function() {
                                 var id = this.issue.entities[0].id;
                                 operationDelete([id], context)();
                             }
-                        }),
-                        new validationIssueFix({
-                            title: t('issues.fix.select_preset.title'),
-                            action: function() {
-                                context.ui().sidebar.showPresetList();
-                            }
                         })
                     ]
                 }));

modules/validations/old_multipolygon.js

@@ -24,7 +24,7 @@ export function validationOldMultipolygon(context) {
                     type: ValidationIssueType.old_multipolygon,
                     severity: ValidationIssueSeverity.warning,
                     message: t('issues.old_multipolygon.message', {multipolygon: multipolygonLabel}),
-                    tooltip: t('issues.old_multipolygon.tooltip'),
+                    tooltip: t('issues.old_multipolygon.tip'),
                     entities: [entity, mistaggedMultipolygon],
                     fixes: [
                         new validationIssueFix({