Ticket #17810: 17810.patch

src/org/openstreetmap/josm/command/SplitWayCommand.java

@@ -42 +42 @@
 
     private static volatile Consumer<String> warningNotifier = Logging::warn;
 
+    private static final class RelationInformation {
+        Boolean warnme = false;
+        Boolean insert = false;
+        Relation relation;
+    }
+
     /**
      * Sets the global warning notifier.
      * @param notifier warning notifier in charge of displaying warning message, if any. Must not be null
@@ -319 +325 @@
                 if (rm.isWay() && rm.getMember() == way) {
                     boolean insert = true;
                     if (relationSpecialTypes.containsKey(type) && "restriction".equals(relationSpecialTypes.get(type))) {
-                        Map<String, Boolean> rValue = treatAsRestriction(r, rm, c, newWays, way, changedWay);
-                        warnme = rValue.containsKey("warnme") ? rValue.get("warnme") : warnme;
-                        insert = rValue.containsKey("insert") ? rValue.get("insert") : insert;
+                        RelationInformation rValue = treatAsRestriction(r, rm, c, newWays, way, changedWay);
+                        warnme = rValue.warnme;
+                        insert = rValue.insert;
+                        c = rValue.relation;
                     } else if (!("route".equals(type)) && !("multipolygon".equals(type))) {
                         warnme = true;
                     }
@@ -409 +416 @@
             );
     }
 
-    private static Map<String, Boolean> treatAsRestriction(Relation r,
+    private static RelationInformation treatAsRestriction(Relation r,
             RelationMember rm, Relation c, Collection<Way> newWays, Way way,
             Way changedWay) {
-        HashMap<String, Boolean> rMap = new HashMap<>();
+        RelationInformation relationInformation = new RelationInformation();
         /* this code assumes the restriction is correct. No real error checking done */
         String role = rm.getRole();
         String type = Optional.ofNullable(r.get("type")).orElse("");
@@ -447 +454 @@
                     }
                     c.addMember(new RelationMember(role, res));
                     c.removeMembersFor(way);
-                    rMap.put("insert", false);
+                    relationInformation.insert = false;
                 }
             } else {
-                rMap.put("insert", false);
+                relationInformation.insert = false;
             }
         } else if (!"via".equals(role)) {
-            rMap.put("warnme", true);
+            relationInformation.warnme = true;
         }
-        return rMap;
+        relationInformation.relation = c;
+        return relationInformation;
     }
 
     static OsmPrimitive findVia(Relation r, String type) {

test/unit/org/openstreetmap/josm/actions/SplitWayActionTest.java

@@ -6 +6 @@
 
 import java.util.Arrays;
 
+import org.junit.Assert;
 import org.junit.Rule;
 import org.junit.Test;
+import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.RelationMember;
 import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
 
@@ -78 +83 @@
                        w1.getNode(i), w1NodesArray[i]);
         }
     }
+
+    /**
+     * Test case: when a way is split with a turn restriction relation,
+     * the relation should not be broken.
+     * see #17810
+     */
+    @Test
+    public void testTicket17810() {
+        DataSet dataSet = new DataSet();
+        Way from = TestUtils.newWay("highway=residential", new Node(new LatLon(0.0, 0.0)),
+                new Node(new LatLon(0.00033, 0.00033)), new Node(new LatLon(0.00066, 0.00066)),
+                new Node(new LatLon(0.001, 0.001)));
+        from.getNodes().forEach(node -> dataSet.addPrimitive(node));
+        dataSet.addPrimitive(from);
+        Node via = from.lastNode();
+        Way to = TestUtils.newWay("highway=residential", new Node(new LatLon(0.002, 0.001)), via);
+        to.getNodes().forEach(node -> {if (!dataSet.containsNode(node)) {dataSet.addPrimitive(node);}});
+        dataSet.addPrimitive(to);
+        Relation restriction = TestUtils.newRelation("type=restriction restriction=no_left_turn",
+                new RelationMember("from", from), new RelationMember("to", to),
+                new RelationMember("via", via));
+        dataSet.addPrimitive(restriction);
+        dataSet.clearSelection();
+        dataSet.addSelected(from.getNode(2), from);
+        SplitWayAction.runOn(dataSet);
+        for (RelationMember member : restriction.getMembers()) {
+            if ("from".equals(member.getRole())) {
+                Assert.assertTrue(member.getWay().containsNode(via));
+            }
+        }
+    }
 }