Simplify use lane (#70)

- use lane always has the straight modifier and indication, so use
  these only
- automatically-generate fixtures

Author: freenerd

CHANGELOG.md

@@ -7,6 +7,7 @@ All notable changes to this project will be documented in this file. For change
 - Run tests per language via LANGUAGE=de npm test
 - Shorter merge instructions (Merge slightly left -> Merge left)
 - Numeric ordinals (1st, 2nd) instead of word ordinals (first, second)
+- use lane only has straight as modifier, so simplify instructions.json and tests
 
 # 0.0.5 2016-10-26
 

index.js

@@ -96,7 +96,7 @@ module.exports = function(version, language) {
                 laneInstruction = this.instructions[version].constants.lanes[this.laneConfig(step)];
 
                 if (!laneInstruction) {
-                    // If the lane combination is not found, default to continue
+                    // If the lane combination is not found, default to continue straight
                     instructionObject = this.instructions[version]['use lane'].no_lanes;
                 }
                 break;

instructions/de.json

@@ -390,19 +390,7 @@
                 "default": "Geradeaus weiterfahren"
             },
             "default": {
-                "default": "{lane_instruction} um {modifier} abzubiegen"
-            },
-            "straight": {
                 "default": "{lane_instruction}"
-            },
-            "left": {
-                "default": "{lane_instruction} um links abzubiegen"
-            },
-            "right": {
-                "default": "{lane_instruction} um rechts abzubiegen"
-            },
-            "uturn": {
-                "default": "{lane_instruction} für eine 180°-Wendung"
             }
         }
     }

instructions/en.json

@@ -390,16 +390,7 @@
                 "default": "Continue straight"
             },
             "default": {
-                "default": "{lane_instruction} to make a {modifier}"
-            },
-            "straight": {
                 "default": "{lane_instruction}"
-            },
-            "left": {
-                "default": "{lane_instruction} to turn left"
-            },
-            "right": {
-                "default": "{lane_instruction} to turn right"
             }
         }
     }

scripts/generate_fixtures.js

@@ -51,7 +51,7 @@ function writeVariations(baseStep, basePath) {
 };
 
 function execute() {
-    var basePath = path.join(__dirname, '..', 'test', 'fixtures', 'v5', type);
+    var basePath = path.join(__dirname, '..', 'test', 'fixtures', 'v5', underscorify(type));
 
     switch (type) {
     case 'modes':
@@ -237,14 +237,77 @@ function execute() {
         basePath = path.join(__dirname, '..', 'test', 'fixtures', 'v5', 'roundabout', 'exit');
         baseStep = {
             maneuver: {
-                modifier: 'left', // roundaboouts don't care about modifiers
+                modifier: 'left', // roundabouts don't care about modifiers
                 type: 'roundabout',
                 exit: 1
             },
             name: '',
         };
         writeVariations(baseStep, basePath);
         break;
+    case 'use lane':
+        function lanesFromConfig(config) {
+            var lanes = [];
+            config.split('').forEach((c) => {
+                switch (c) {
+                case 'x':
+                    lanes.push({
+                        indications: ["straight"],
+                        valid: false
+                    });
+                    break;
+                case 'o':
+                    lanes.push({
+                        indications: ["straight"],
+                        valid: true
+                    });
+                    break;
+                default:
+                    throw 'Invalid config ' + c
+                }
+            });
+            return lanes;
+        }
+        function writeLaneConfig(config) {
+            var step = Object.assign(clone(baseStep));
+            step.intersections[0].lanes = lanesFromConfig(config);
+            write(step, `${basePath}/${config}`);
+        }
+
+        var baseStep = {
+            maneuver: {
+                modifier: 'straight',
+                type: 'use lane'
+            },
+            intersections: [
+                {
+                    location: [ 13.39677,52.54366 ],
+                    in: 1,
+                    out: 2,
+                    bearings: [ 10, 20 ],
+                    entry: [ true, false ]
+                }
+            ],
+            name: '',
+        };
+
+        // lane combinations
+        [
+            'o',
+            'ooo',
+            'oox',
+            'xoo',
+            'xox',
+            'oxo',
+            'xxoo',
+            'ooxx',
+            'xxoxo',
+            'xxooxx',
+            'oooxxo'
+        ].forEach((c) => {
+            writeLaneConfig(c);
+        });
+        break;
     default:
         console.error('Need to provide a type as first argument. Supported values:' + types.join(' ,'));
         process.exit(1);