mirror of
https://github.com/FoggedLens/iD.git
synced 2026-02-13 17:23:02 +00:00
668 lines
33 KiB
JavaScript
668 lines
33 KiB
JavaScript
describe('iD.actionReverse', function () {
|
|
it('reverses the order of nodes in the way', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, way]));
|
|
expect(graph.entity(way.id).nodes).to.eql([node2.id, node1.id]);
|
|
});
|
|
|
|
it('preserves non-directional tags', function () {
|
|
var way = iD.osmWay({tags: {'highway': 'residential'}});
|
|
var graph = iD.coreGraph([way]);
|
|
|
|
graph = iD.actionReverse(way.id)(graph);
|
|
expect(graph.entity(way.id).tags).to.eql({'highway': 'residential'});
|
|
});
|
|
|
|
|
|
describe('reverses directional tags on nodes', function () {
|
|
it('reverses relative directions', function () {
|
|
var node1 = iD.osmNode({ tags: { 'direction': 'forward' } });
|
|
var graph = iD.actionReverse(node1.id)(iD.coreGraph([node1]));
|
|
expect(graph.entity(node1.id).tags).to.eql({ 'direction': 'backward' });
|
|
});
|
|
|
|
it('reverses relative directions for arbitrary direction tags', function () {
|
|
var node1 = iD.osmNode({ tags: { 'traffic_sign:direction': 'forward' } });
|
|
var graph = iD.actionReverse(node1.id)(iD.coreGraph([node1]));
|
|
expect(graph.entity(node1.id).tags).to.eql({ 'traffic_sign:direction': 'backward' });
|
|
});
|
|
|
|
it('reverses absolute directions, cardinal compass points', function () {
|
|
var node1 = iD.osmNode({ tags: { 'direction': 'E' } });
|
|
var graph = iD.actionReverse(node1.id)(iD.coreGraph([node1]));
|
|
expect(graph.entity(node1.id).tags).to.eql({ 'direction': 'W' });
|
|
});
|
|
|
|
it('reverses absolute directions, intercardinal compass points', function () {
|
|
var node1 = iD.osmNode({ tags: { 'direction': 'SE' } });
|
|
var graph = iD.actionReverse(node1.id)(iD.coreGraph([node1]));
|
|
expect(graph.entity(node1.id).tags).to.eql({ 'direction': 'NW' });
|
|
});
|
|
|
|
it('reverses absolute directions, secondary intercardinal compass points', function () {
|
|
var node1 = iD.osmNode({ tags: { 'direction': 'NNE' } });
|
|
var graph = iD.actionReverse(node1.id)(iD.coreGraph([node1]));
|
|
expect(graph.entity(node1.id).tags).to.eql({ 'direction': 'SSW' });
|
|
});
|
|
|
|
it('reverses absolute directions, 0 degrees', function () {
|
|
var node1 = iD.osmNode({ tags: { 'direction': '0' } });
|
|
var graph = iD.actionReverse(node1.id)(iD.coreGraph([node1]));
|
|
expect(graph.entity(node1.id).tags).to.eql({ 'direction': '180' });
|
|
});
|
|
|
|
it('reverses absolute directions, positive degrees', function () {
|
|
var node1 = iD.osmNode({ tags: { 'direction': '85.5' } });
|
|
var graph = iD.actionReverse(node1.id)(iD.coreGraph([node1]));
|
|
expect(graph.entity(node1.id).tags).to.eql({ 'direction': '265.5' });
|
|
});
|
|
|
|
it('reverses absolute directions, positive degrees > 360', function () {
|
|
var node1 = iD.osmNode({ tags: { 'direction': '385.5' } });
|
|
var graph = iD.actionReverse(node1.id)(iD.coreGraph([node1]));
|
|
expect(graph.entity(node1.id).tags).to.eql({ 'direction': '205.5' });
|
|
});
|
|
|
|
it('reverses absolute directions, negative degrees', function () {
|
|
var node1 = iD.osmNode({ tags: { 'direction': '-85.5' } });
|
|
var graph = iD.actionReverse(node1.id)(iD.coreGraph([node1]));
|
|
expect(graph.entity(node1.id).tags).to.eql({ 'direction': '94.5' });
|
|
});
|
|
|
|
it('reverses directions with multiple semicolon separated values', function () {
|
|
var node1 = iD.osmNode({ tags: { 'direction': 'N;90' } });
|
|
var graph = iD.actionReverse(node1.id)(iD.coreGraph([node1]));
|
|
expect(graph.entity(node1.id).tags).to.eql({ 'direction': 'S;270' });
|
|
});
|
|
|
|
it('reverses directions with multiple semicolon separated values, preserves non-directional part', function () {
|
|
var node1 = iD.osmNode({ tags: { 'direction': '0;error' } });
|
|
var graph = iD.actionReverse(node1.id)(iD.coreGraph([node1]));
|
|
expect(graph.entity(node1.id).tags).to.eql({ 'direction': '180;error' });
|
|
});
|
|
|
|
it('preserves non-directional tags', function () {
|
|
var node1 = iD.osmNode({ tags: { 'traffic_sign': 'maxspeed' } });
|
|
var graph = iD.actionReverse(node1.id)(iD.coreGraph([node1]));
|
|
expect(graph.entity(node1.id).tags).to.eql({ 'traffic_sign': 'maxspeed' });
|
|
});
|
|
|
|
it('preserves non-reversible direction tags', function () {
|
|
var node1 = iD.osmNode({ tags: { 'direction': 'both' } });
|
|
var graph = iD.actionReverse(node1.id)(iD.coreGraph([node1]));
|
|
expect(graph.entity(node1.id).tags).to.eql({ 'direction': 'both' });
|
|
});
|
|
});
|
|
|
|
|
|
describe('reverses oneway', function () {
|
|
it('preserves oneway tags', function () {
|
|
var way = iD.osmWay({tags: {'oneway': 'yes'}});
|
|
var graph = iD.coreGraph([way]);
|
|
|
|
graph = iD.actionReverse(way.id)(graph);
|
|
expect(graph.entity(way.id).tags).to.eql({'oneway': 'yes'});
|
|
});
|
|
|
|
it('reverses oneway tags if reverseOneway: true is provided', function () {
|
|
var graph = iD.coreGraph([
|
|
iD.osmWay({id: 'yes', tags: {oneway: 'yes'}}),
|
|
iD.osmWay({id: 'no', tags: {oneway: 'no'}}),
|
|
iD.osmWay({id: '1', tags: {oneway: '1'}}),
|
|
iD.osmWay({id: '-1', tags: {oneway: '-1'}})
|
|
]);
|
|
|
|
expect(iD.actionReverse('yes', {reverseOneway: true})(graph)
|
|
.entity('yes').tags).to.eql({oneway: '-1'}, 'yes');
|
|
expect(iD.actionReverse('no', {reverseOneway: true})(graph)
|
|
.entity('no').tags).to.eql({oneway: 'no'}, 'no');
|
|
expect(iD.actionReverse('1', {reverseOneway: true})(graph)
|
|
.entity('1').tags).to.eql({oneway: '-1'}, '1');
|
|
expect(iD.actionReverse('-1', {reverseOneway: true})(graph)
|
|
.entity('-1').tags).to.eql({oneway: 'yes'}, '-1');
|
|
});
|
|
|
|
it('ignores other oneway tags', function () {
|
|
var graph = iD.coreGraph([
|
|
iD.osmWay({id: 'alternating', tags: {oneway: 'alternating'}}),
|
|
iD.osmWay({id: 'reversible', tags: {oneway: 'reversible'}}),
|
|
iD.osmWay({id: 'dummy', tags: {oneway: 'dummy'}})
|
|
]);
|
|
|
|
expect(iD.actionReverse('alternating', {reverseOneway: true})(graph)
|
|
.entity('alternating').tags).to.eql({oneway: 'alternating'}, 'alternating');
|
|
expect(iD.actionReverse('reversible', {reverseOneway: true})(graph)
|
|
.entity('reversible').tags).to.eql({oneway: 'reversible'}, 'reversible');
|
|
expect(iD.actionReverse('dummy', {reverseOneway: true})(graph)
|
|
.entity('dummy').tags).to.eql({oneway: 'dummy'}, 'dummy');
|
|
});
|
|
});
|
|
|
|
|
|
describe('reverses incline', function () {
|
|
it('transforms incline=up ⟺ incline=down', function () {
|
|
var way = iD.osmWay({tags: {'incline': 'up'}});
|
|
var graph = iD.coreGraph([way]);
|
|
|
|
graph = iD.actionReverse(way.id)(graph);
|
|
expect(graph.entity(way.id).tags).to.eql({'incline': 'down'});
|
|
|
|
graph = iD.actionReverse(way.id)(graph);
|
|
expect(graph.entity(way.id).tags).to.eql({'incline': 'up'});
|
|
});
|
|
|
|
it('negates numeric-valued incline tags', function () {
|
|
var way = iD.osmWay({tags: {'incline': '5%'}});
|
|
var graph = iD.coreGraph([way]);
|
|
|
|
graph = iD.actionReverse(way.id)(graph);
|
|
expect(graph.entity(way.id).tags).to.eql({'incline': '-5%'});
|
|
|
|
graph = iD.actionReverse(way.id)(graph);
|
|
expect(graph.entity(way.id).tags).to.eql({'incline': '5%'});
|
|
|
|
way = iD.osmWay({tags: {'incline': '.8°'}});
|
|
graph = iD.coreGraph([way]);
|
|
|
|
graph = iD.actionReverse(way.id)(graph);
|
|
expect(graph.entity(way.id).tags).to.eql({'incline': '-.8°'});
|
|
});
|
|
});
|
|
|
|
|
|
describe('reverses directional keys on ways', function () {
|
|
it('transforms *:right=* ⟺ *:left=*', function () {
|
|
var way = iD.osmWay({tags: {'cycleway:right': 'lane'}});
|
|
var graph = iD.coreGraph([way]);
|
|
|
|
graph = iD.actionReverse(way.id)(graph);
|
|
expect(graph.entity(way.id).tags).to.eql({'cycleway:left': 'lane'});
|
|
|
|
graph = iD.actionReverse(way.id)(graph);
|
|
expect(graph.entity(way.id).tags).to.eql({'cycleway:right': 'lane'});
|
|
});
|
|
|
|
it('transforms *:right:*=* ⟺ *:left:*=*', function () {
|
|
var way = iD.osmWay({tags: {'cycleway:right:surface': 'paved'}});
|
|
var graph = iD.coreGraph([way]);
|
|
|
|
graph = iD.actionReverse(way.id)(graph);
|
|
expect(graph.entity(way.id).tags).to.eql({'cycleway:left:surface': 'paved'});
|
|
|
|
graph = iD.actionReverse(way.id)(graph);
|
|
expect(graph.entity(way.id).tags).to.eql({'cycleway:right:surface': 'paved'});
|
|
});
|
|
|
|
it('transforms *:forward=* ⟺ *:backward=*', function () {
|
|
var way = iD.osmWay({tags: {'maxspeed:forward': '25'}});
|
|
var graph = iD.coreGraph([way]);
|
|
|
|
graph = iD.actionReverse(way.id)(graph);
|
|
expect(graph.entity(way.id).tags).to.eql({'maxspeed:backward': '25'});
|
|
|
|
graph = iD.actionReverse(way.id)(graph);
|
|
expect(graph.entity(way.id).tags).to.eql({'maxspeed:forward': '25'});
|
|
});
|
|
|
|
it('transforms multiple directional tags', function () {
|
|
var way = iD.osmWay({tags: {'maxspeed:forward': '25', 'maxspeed:backward': '30'}});
|
|
var graph = iD.coreGraph([way]);
|
|
|
|
graph = iD.actionReverse(way.id)(graph);
|
|
expect(graph.entity(way.id).tags).to.eql({'maxspeed:backward': '25', 'maxspeed:forward': '30'});
|
|
});
|
|
});
|
|
|
|
|
|
describe('reverses directional values on ways', function () {
|
|
it('transforms *=up ⟺ *=down', function () {
|
|
var graph = iD.coreGraph([
|
|
iD.osmWay({id: 'inclineU', tags: {incline: 'up'}}),
|
|
iD.osmWay({id: 'directionU', tags: {direction: 'up'}}),
|
|
iD.osmWay({id: 'inclineD', tags: {incline: 'down'}}),
|
|
iD.osmWay({id: 'directionD', tags: {direction: 'down'}})
|
|
]);
|
|
|
|
expect(iD.actionReverse('inclineU')(graph)
|
|
.entity('inclineU').tags).to.eql({incline: 'down'}, 'inclineU');
|
|
expect(iD.actionReverse('directionU')(graph)
|
|
.entity('directionU').tags).to.eql({direction: 'down'}, 'directionU');
|
|
|
|
expect(iD.actionReverse('inclineD')(graph)
|
|
.entity('inclineD').tags).to.eql({incline: 'up'}, 'inclineD');
|
|
expect(iD.actionReverse('directionD')(graph)
|
|
.entity('directionD').tags).to.eql({direction: 'up'}, 'directionD');
|
|
});
|
|
|
|
it('skips *=up ⟺ *=down for ignored tags', function () {
|
|
var graph = iD.coreGraph([
|
|
iD.osmWay({id: 'name', tags: {name: 'up'}}),
|
|
iD.osmWay({id: 'note', tags: {note: 'up'}}),
|
|
iD.osmWay({id: 'ref', tags: {ref: 'down'}}),
|
|
iD.osmWay({id: 'description', tags: {description: 'down'}})
|
|
]);
|
|
|
|
expect(iD.actionReverse('name')(graph)
|
|
.entity('name').tags).to.eql({name: 'up'}, 'name');
|
|
expect(iD.actionReverse('note')(graph)
|
|
.entity('note').tags).to.eql({note: 'up'}, 'note');
|
|
expect(iD.actionReverse('ref')(graph)
|
|
.entity('ref').tags).to.eql({ref: 'down'}, 'ref');
|
|
expect(iD.actionReverse('description')(graph)
|
|
.entity('description').tags).to.eql({description: 'down'}, 'description');
|
|
});
|
|
|
|
it('transforms *=forward ⟺ *=backward', function () {
|
|
var graph = iD.coreGraph([
|
|
iD.osmWay({id: 'conveyingF', tags: {conveying: 'forward'}}),
|
|
iD.osmWay({id: 'directionF', tags: {direction: 'forward'}}),
|
|
iD.osmWay({id: 'priorityF', tags: {priority: 'forward'}}),
|
|
iD.osmWay({id: 'trolley_wireF', tags: {trolley_wire: 'forward'}}),
|
|
iD.osmWay({id: 'conveyingB', tags: {conveying: 'backward'}}),
|
|
iD.osmWay({id: 'directionB', tags: {direction: 'backward'}}),
|
|
iD.osmWay({id: 'priorityB', tags: {priority: 'backward'}}),
|
|
iD.osmWay({id: 'trolley_wireB', tags: {trolley_wire: 'backward'}})
|
|
]);
|
|
|
|
expect(iD.actionReverse('conveyingF')(graph)
|
|
.entity('conveyingF').tags).to.eql({conveying: 'backward'}, 'conveyingF');
|
|
expect(iD.actionReverse('directionF')(graph)
|
|
.entity('directionF').tags).to.eql({direction: 'backward'}, 'directionF');
|
|
expect(iD.actionReverse('priorityF')(graph)
|
|
.entity('priorityF').tags).to.eql({priority: 'backward'}, 'priorityF');
|
|
expect(iD.actionReverse('trolley_wireF')(graph)
|
|
.entity('trolley_wireF').tags).to.eql({trolley_wire: 'backward'}, 'trolley_wireF');
|
|
|
|
expect(iD.actionReverse('conveyingB')(graph)
|
|
.entity('conveyingB').tags).to.eql({conveying: 'forward'}, 'conveyingB');
|
|
expect(iD.actionReverse('directionB')(graph)
|
|
.entity('directionB').tags).to.eql({direction: 'forward'}, 'directionB');
|
|
expect(iD.actionReverse('priorityB')(graph)
|
|
.entity('priorityB').tags).to.eql({priority: 'forward'}, 'priorityB');
|
|
expect(iD.actionReverse('trolley_wireB')(graph)
|
|
.entity('trolley_wireB').tags).to.eql({trolley_wire: 'forward'}, 'trolley_wireB');
|
|
});
|
|
|
|
it('drops "s" from forwards/backwards when reversing', function () {
|
|
var graph = iD.coreGraph([
|
|
iD.osmWay({id: 'conveyingF', tags: {conveying: 'forwards'}}),
|
|
iD.osmWay({id: 'conveyingB', tags: {conveying: 'backwards'}})
|
|
]);
|
|
|
|
expect(iD.actionReverse('conveyingF')(graph)
|
|
.entity('conveyingF').tags).to.eql({conveying: 'backward'}, 'conveyingF');
|
|
expect(iD.actionReverse('conveyingB')(graph)
|
|
.entity('conveyingB').tags).to.eql({conveying: 'forward'}, 'conveyingB');
|
|
});
|
|
|
|
it('skips *=forward ⟺ *=backward for ignored tags', function () {
|
|
var graph = iD.coreGraph([
|
|
iD.osmWay({id: 'name', tags: {name: 'forward'}}),
|
|
iD.osmWay({id: 'note', tags: {note: 'forwards'}}),
|
|
iD.osmWay({id: 'ref', tags: {ref: 'backward'}}),
|
|
iD.osmWay({id: 'description', tags: {description: 'backwards'}})
|
|
]);
|
|
|
|
expect(iD.actionReverse('name')(graph)
|
|
.entity('name').tags).to.eql({name: 'forward'}, 'name');
|
|
expect(iD.actionReverse('note')(graph)
|
|
.entity('note').tags).to.eql({note: 'forwards'}, 'note');
|
|
expect(iD.actionReverse('ref')(graph)
|
|
.entity('ref').tags).to.eql({ref: 'backward'}, 'ref');
|
|
expect(iD.actionReverse('description')(graph)
|
|
.entity('description').tags).to.eql({description: 'backwards'}, 'description');
|
|
});
|
|
|
|
it('transforms *=right ⟺ *=left', function () {
|
|
var graph = iD.coreGraph([
|
|
iD.osmWay({id: 'sidewalkR', tags: {sidewalk: 'right'}}),
|
|
iD.osmWay({id: 'sidewalkL', tags: {sidewalk: 'left'}})
|
|
]);
|
|
|
|
expect(iD.actionReverse('sidewalkR')(graph)
|
|
.entity('sidewalkR').tags).to.eql({sidewalk: 'left'}, 'sidewalkR');
|
|
expect(iD.actionReverse('sidewalkL')(graph)
|
|
.entity('sidewalkL').tags).to.eql({sidewalk: 'right'}, 'sidewalkL');
|
|
});
|
|
|
|
it('skips *=right ⟺ *=left for ignored tags', function () {
|
|
var graph = iD.coreGraph([
|
|
iD.osmWay({id: 'name', tags: {name: 'right'}}),
|
|
iD.osmWay({id: 'note', tags: {note: 'right'}}),
|
|
iD.osmWay({id: 'ref', tags: {ref: 'left'}}),
|
|
iD.osmWay({id: 'description', tags: {description: 'left'}})
|
|
]);
|
|
|
|
expect(iD.actionReverse('name')(graph)
|
|
.entity('name').tags).to.eql({name: 'right'}, 'name');
|
|
expect(iD.actionReverse('note')(graph)
|
|
.entity('note').tags).to.eql({note: 'right'}, 'note');
|
|
expect(iD.actionReverse('ref')(graph)
|
|
.entity('ref').tags).to.eql({ref: 'left'}, 'ref');
|
|
expect(iD.actionReverse('description')(graph)
|
|
.entity('description').tags).to.eql({description: 'left'}, 'description');
|
|
});
|
|
});
|
|
|
|
|
|
describe('reverses relation roles', function () {
|
|
it('transforms role=forward ⟺ role=backward in member relations', function () {
|
|
var graph = iD.coreGraph([
|
|
iD.osmNode({id: 'n1'}),
|
|
iD.osmNode({id: 'n2'}),
|
|
iD.osmWay({id: 'w1', nodes: ['n1', 'n2'], tags: {highway: 'residential'}}),
|
|
iD.osmRelation({id: 'forward', members: [{type: 'way', id: 'w1', role: 'forward'}]}),
|
|
iD.osmRelation({id: 'backward', members: [{type: 'way', id: 'w1', role: 'backward'}]})
|
|
]);
|
|
|
|
expect(iD.actionReverse('w1')(graph)
|
|
.entity('forward').members[0].role).to.eql('backward', 'forward');
|
|
expect(iD.actionReverse('w1')(graph)
|
|
.entity('backward').members[0].role).to.eql('forward', 'backward');
|
|
});
|
|
|
|
it('drops "s" from forwards/backwards when reversing', function () {
|
|
var graph = iD.coreGraph([
|
|
iD.osmNode({id: 'n1'}),
|
|
iD.osmNode({id: 'n2'}),
|
|
iD.osmWay({id: 'w1', nodes: ['n1', 'n2'], tags: {highway: 'residential'}}),
|
|
iD.osmRelation({id: 'forwards', members: [{type: 'way', id: 'w1', role: 'forwards'}]}),
|
|
iD.osmRelation({id: 'backwards', members: [{type: 'way', id: 'w1', role: 'backwards'}]})
|
|
]);
|
|
|
|
expect(iD.actionReverse('w1')(graph)
|
|
.entity('forwards').members[0].role).to.eql('backward', 'forwards');
|
|
expect(iD.actionReverse('w1')(graph)
|
|
.entity('backwards').members[0].role).to.eql('forward', 'backwards');
|
|
});
|
|
|
|
it('doesn\'t transform role=north ⟺ role=south in member relations', function () {
|
|
var graph = iD.coreGraph([
|
|
iD.osmNode({id: 'n1'}),
|
|
iD.osmNode({id: 'n2'}),
|
|
iD.osmWay({id: 'w1', nodes: ['n1', 'n2'], tags: {highway: 'residential'}}),
|
|
iD.osmRelation({id: 'north', members: [{type: 'way', id: 'w1', role: 'north'}]}),
|
|
iD.osmRelation({id: 'south', members: [{type: 'way', id: 'w1', role: 'south'}]})
|
|
]);
|
|
|
|
expect(iD.actionReverse('w1')(graph)
|
|
.entity('north').members[0].role).to.eql('north', 'north');
|
|
expect(iD.actionReverse('w1')(graph)
|
|
.entity('south').members[0].role).to.eql('south', 'south');
|
|
});
|
|
|
|
it('doesn\'t transform role=east ⟺ role=west in member relations', function () {
|
|
var graph = iD.coreGraph([
|
|
iD.osmNode({id: 'n1'}),
|
|
iD.osmNode({id: 'n2'}),
|
|
iD.osmWay({id: 'w1', nodes: ['n1', 'n2'], tags: {highway: 'residential'}}),
|
|
iD.osmRelation({id: 'east', members: [{type: 'way', id: 'w1', role: 'east'}]}),
|
|
iD.osmRelation({id: 'west', members: [{type: 'way', id: 'w1', role: 'west'}]})
|
|
]);
|
|
|
|
expect(iD.actionReverse('w1')(graph)
|
|
.entity('east').members[0].role).to.eql('east', 'east');
|
|
expect(iD.actionReverse('w1')(graph)
|
|
.entity('west').members[0].role).to.eql('west', 'west');
|
|
});
|
|
|
|
it('ignores directionless roles in member relations', function () {
|
|
var graph = iD.coreGraph([
|
|
iD.osmNode({id: 'n1'}),
|
|
iD.osmNode({id: 'n2'}),
|
|
iD.osmWay({id: 'w1', nodes: ['n1', 'n2'], tags: {highway: 'residential'}}),
|
|
iD.osmRelation({id: 'ignore', members: [{type: 'way', id: 'w1', role: 'ignore'}]}),
|
|
iD.osmRelation({id: 'empty', members: [{type: 'way', id: 'w1', role: ''}]})
|
|
]);
|
|
|
|
expect(iD.actionReverse('w1')(graph)
|
|
.entity('ignore').members[0].role).to.eql('ignore', 'ignore');
|
|
expect(iD.actionReverse('w1')(graph)
|
|
.entity('empty').members[0].role).to.eql('', 'empty');
|
|
});
|
|
});
|
|
|
|
|
|
describe('reverses directional values on childnodes', function () {
|
|
// For issue #3076
|
|
it('reverses the direction of a forward facing stop sign on the way', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode({tags: {'direction': 'forward', 'highway': 'stop'}});
|
|
var node3 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id, node3.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, node3, way]));
|
|
var target = graph.entity(node2.id);
|
|
expect(target.tags.direction).to.eql('backward');
|
|
});
|
|
|
|
it('reverses the direction of a backward facing stop sign on the way', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode({tags: {'direction': 'backward', 'highway': 'stop'}});
|
|
var node3 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id, node3.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, node3, way]));
|
|
var target = graph.entity(node2.id);
|
|
expect(target.tags.direction).to.eql('forward');
|
|
});
|
|
|
|
it('reverses the direction of a left facing stop sign on the way', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode({tags: {'direction': 'left', 'highway': 'stop'}});
|
|
var node3 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id, node3.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, node3, way]));
|
|
var target = graph.entity(node2.id);
|
|
expect(target.tags.direction).to.eql('right');
|
|
});
|
|
|
|
it('reverses the direction of a right facing stop sign on the way', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode({tags: {'direction': 'right', 'highway': 'stop'}});
|
|
var node3 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id, node3.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, node3, way]));
|
|
var target = graph.entity(node2.id);
|
|
expect(target.tags.direction).to.eql('left');
|
|
});
|
|
|
|
it('does not assign a direction to a directionless stop sign on the way during a reverse', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode({tags: {'highway': 'stop'}});
|
|
var node3 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id, node3.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, node3, way]));
|
|
var target = graph.entity(node2.id);
|
|
expect(target.tags.direction).to.be.undefined;
|
|
});
|
|
|
|
it('ignores directions other than forward or backward on attached stop sign during a reverse', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode({tags: {'direction': 'empty', 'highway': 'stop'}});
|
|
var node3 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id, node3.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, node3, way]));
|
|
var target = graph.entity(node2.id);
|
|
expect(target.tags.direction).to.eql('empty');
|
|
});
|
|
});
|
|
|
|
|
|
describe('reverses directional keys on childnodes', function () {
|
|
it('reverses the direction of a forward facing traffic sign on the way', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode({tags: {'traffic_sign:forward': 'stop'}});
|
|
var node3 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id, node3.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, node3, way]));
|
|
var target = graph.entity(node2.id);
|
|
expect(target.tags['traffic_sign:backward']).to.eql('stop');
|
|
});
|
|
|
|
it('reverses the direction of a backward facing stop sign on the way', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode({tags: {'traffic_sign:backward': 'stop'}});
|
|
var node3 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id, node3.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, node3, way]));
|
|
var target = graph.entity(node2.id);
|
|
expect(target.tags['traffic_sign:forward']).to.eql('stop');
|
|
});
|
|
|
|
it('reverses the direction of a left facing traffic sign on the way', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode({tags: {'traffic_sign:left': 'stop'}});
|
|
var node3 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id, node3.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, node3, way]));
|
|
var target = graph.entity(node2.id);
|
|
expect(target.tags['traffic_sign:right']).to.eql('stop');
|
|
});
|
|
|
|
it('reverses the direction of a right facing stop sign on the way', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode({tags: {'traffic_sign:right': 'stop'}});
|
|
var node3 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id, node3.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, node3, way]));
|
|
var target = graph.entity(node2.id);
|
|
expect(target.tags['traffic_sign:left']).to.eql('stop');
|
|
});
|
|
|
|
// For issue #4595
|
|
it('reverses the direction of a forward facing traffic_signals on the way', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode({tags: { 'traffic_signals:direction': 'forward', 'highway': 'traffic_signals' }});
|
|
var node3 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id, node3.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, node3, way]));
|
|
var target = graph.entity(node2.id);
|
|
expect(target.tags['traffic_signals:direction']).to.eql('backward');
|
|
});
|
|
|
|
it('reverses the direction of a backward facing traffic_signals on the way', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode({tags: { 'traffic_signals:direction': 'backward', 'highway': 'traffic_signals' }});
|
|
var node3 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id, node3.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, node3, way]));
|
|
var target = graph.entity(node2.id);
|
|
expect(target.tags['traffic_signals:direction']).to.eql('forward');
|
|
});
|
|
|
|
it('reverses the direction of a left facing traffic_signals on the way', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode({tags: { 'traffic_signals:direction': 'left', 'highway': 'traffic_signals' }});
|
|
var node3 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id, node3.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, node3, way]));
|
|
var target = graph.entity(node2.id);
|
|
expect(target.tags['traffic_signals:direction']).to.eql('right');
|
|
});
|
|
|
|
it('reverses the direction of a right facing traffic_signals on the way', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode({tags: { 'traffic_signals:direction': 'right', 'highway': 'traffic_signals' }});
|
|
var node3 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id, node3.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, node3, way]));
|
|
var target = graph.entity(node2.id);
|
|
expect(target.tags['traffic_signals:direction']).to.eql('left');
|
|
});
|
|
|
|
it('does not assign a direction to a directionless traffic_signals on the way during a reverse', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode({tags: { 'highway': 'traffic_signals' }});
|
|
var node3 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id, node3.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, node3, way]));
|
|
var target = graph.entity(node2.id);
|
|
expect(target.tags['traffic_signals:direction']).to.be.undefined;
|
|
});
|
|
|
|
it('ignores directions other than forward or backward on attached traffic_signals during a reverse', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode({tags: { 'traffic_signals:direction': 'empty', 'highway': 'traffic_signals' }});
|
|
var node3 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id, node3.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, node3, way]));
|
|
var target = graph.entity(node2.id);
|
|
expect(target.tags['traffic_signals:direction']).to.eql('empty');
|
|
});
|
|
});
|
|
|
|
|
|
describe('does not reverse values which are relative to another reversed tag', function () {
|
|
it('preserves the turn direction of a single lane road', function () {
|
|
var way = iD.osmWay({tags: {'turn:lanes': 'right'}});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([way]));
|
|
var target = graph.entity(way.id);
|
|
expect(target.tags['turn:lanes']).to.eql('right');
|
|
});
|
|
|
|
it('preserves the turn directions of a multi-lane road', function () {
|
|
var way = iD.osmWay({tags: {'turn:lanes': 'through|through|right'}});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([way]));
|
|
var target = graph.entity(way.id);
|
|
expect(target.tags['turn:lanes']).to.eql('through|through|right');
|
|
});
|
|
|
|
// https://github.com/openstreetmap/iD/issues/5674
|
|
it('preserves the turn direction of each direction with a single lane', function () {
|
|
var way = iD.osmWay({tags: {'turn:lanes:forward': 'right', 'turn:lanes:backward': 'left'}});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([way]));
|
|
var target = graph.entity(way.id);
|
|
expect(target.tags['turn:lanes:backward']).to.eql('right');
|
|
expect(target.tags['turn:lanes:forward']).to.eql('left');
|
|
});
|
|
|
|
it('preserves the turn direction of each direction with multiple lanes', function () {
|
|
var way = iD.osmWay({tags: {'turn:lanes:forward': 'through|right', 'turn:lanes:backward': 'through|through|left'}});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([way]));
|
|
var target = graph.entity(way.id);
|
|
expect(target.tags['turn:lanes:backward']).to.eql('through|right');
|
|
expect(target.tags['turn:lanes:forward']).to.eql('through|through|left');
|
|
});
|
|
|
|
it('preserves the turn direction of explicitly bidirectional turn lane values', function () {
|
|
var way = iD.osmWay({tags: {'turn:lanes:both_ways': 'left'}});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([way]));
|
|
var target = graph.entity(way.id);
|
|
expect(target.tags['turn:lanes:both_ways']).to.eql('left');
|
|
});
|
|
|
|
it('preserves the value of the side tag of a cycling waiting aid', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode({tags: {
|
|
'highway': 'cyclist_waiting_aid',
|
|
'direction': 'forward',
|
|
'side': 'right'
|
|
}});
|
|
var node3 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id, node3.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, node3, way]));
|
|
var target = graph.entity(node2.id);
|
|
expect(target.tags.direction).to.eql('backward');
|
|
expect(target.tags.side).to.eql('right');
|
|
});
|
|
|
|
it('preserves the direction of a red turn at a traffic signal', function () {
|
|
var node1 = iD.osmNode();
|
|
var node2 = iD.osmNode({tags: {
|
|
'highway': 'traffic_signals',
|
|
'traffic_signals:direction': 'forward',
|
|
'red_turn:right': 'no',
|
|
'red_turn:right:bicycle': 'yes'
|
|
}});
|
|
var node3 = iD.osmNode();
|
|
var way = iD.osmWay({nodes: [node1.id, node2.id, node3.id]});
|
|
var graph = iD.actionReverse(way.id)(iD.coreGraph([node1, node2, node3, way]));
|
|
var target = graph.entity(node2.id);
|
|
expect(target.tags['traffic_signals:direction']).to.eql('backward');
|
|
expect(target.tags['red_turn:right']).to.eql('no');
|
|
expect(target.tags['red_turn:right:bicycle']).to.eql('yes');
|
|
});
|
|
});
|
|
});
|