Fix shared-midpoint dragging. Fixes #432

js/id/behavior/drag_midpoint.js

@@ -8,10 +8,18 @@ iD.behavior.DragMidpoint = function(mode) {
             return projection(d.loc);
         })
         .on('start', function(d) {
+            var w, nds, args = [iD.actions.AddNode(d.node)];
             d.node = iD.Node({loc: d.loc});
-            history.perform(
-                iD.actions.AddNode(d.node),
-                iD.actions.AddWayNode(d.way, d.node.id, d.index));
+            for (var i = 0; i < d.ways.length; i++) {
+                w = d.ways[i], nds = w.nodes;
+                for (var j = 0; j < nds.length; j++) {
+                    if ((nds[j] === d.nodes[0] && nds[j + 1] === d.nodes[1]) ||
+                        (nds[j] === d.nodes[1] && nds[j + 1] === d.nodes[0])) {
+                        args.push(iD.actions.AddWayNode(w.id, d.node.id, j + 1));
+                    }
+                }
+            }
+            history.perform.apply(history, args);
         })
         .on('move', function(d) {
             d3.event.sourceEvent.stopPropagation();

js/id/renderer/map.js

@@ -91,7 +91,15 @@ iD.Map = function() {
             }
 
             all = _.compact(_.values(only));
-            filter = function(d) { return d.midpoint ? d.way in only : d.id in only; };
+            filter = function(d) {
+                if (d.midpoint) {
+                    for (var i = 0; i < d.ways.length; i++) {
+                        if (d.ways[i].id in only) return true;
+                    }
+                } else {
+                    return d.id in only;
+                }
+            };
         }
 
         if (all.length > 100000) {

js/id/svg/midpoints.js

@@ -1,31 +1,41 @@
 iD.svg.Midpoints = function(projection) {
     return function drawMidpoints(surface, graph, entities, filter) {
-        var midpoints = [];
+        var midpoints = {};
 
         for (var i = 0; i < entities.length; i++) {
-            var entity = entities[i];
+            if (entities[i].type !== 'way') continue;
 
-            if (entity.type !== 'way')
-                continue;
+            var entity = entities[i],
+                nodes = graph.childNodes(entity);
 
-            var nodes = graph.childNodes(entity);
+            // skip the last node because it is always repeated
             for (var j = 0; j < nodes.length - 1; j++) {
-                var a = projection(nodes[j].loc);
-                var b = projection(nodes[j + 1].loc);
-                if (iD.geo.dist(a, b) > 40) {
-                    midpoints.push({
-                        loc: iD.geo.interp(nodes[j].loc, nodes[j + 1].loc, 0.5),
-                        way: entity.id,
-                        index: j + 1,
+
+                var a = nodes[j],
+                    b = nodes[j + 1],
+                    id = [a.id, b.id].sort().join('-');
+
+                if (!midpoints[id] &&
+                    iD.geo.dist(projection(a.loc), projection(b.loc)) > 40) {
+
+                    var midpoint_loc = iD.geo.interp(a.loc, b.loc, 0.5),
+                        parents = _.intersection(graph.parentWays(a),
+                            graph.parentWays(b));
+
+                    midpoints[id] = {
+                        loc: midpoint_loc,
+                        ways: parents,
+                        nodes: [a.id, b.id],
+                        id: id,
                         midpoint: true
-                    });
+                    };
                 }
             }
         }
 
         var groups = surface.select('.layer-hit').selectAll('g.midpoint')
             .filter(filter)
-            .data(midpoints, function (d) { return [d.way, d.index].join(","); });
+            .data(_.values(midpoints), function (d) { return [d.parents, d.id].join(","); });
 
         var group = groups.enter()
             .insert('g', ':first-child')