Fix lane count calculation - use Scheme structs to avoid re-reading/re-interpreting tags

data/tests.yml

@@ -774,6 +774,7 @@
   tags:
     highway: 'road'
     lanes: '3'
+    lanes:forward: '2'
     sidewalk: 'no'
     shoulder: 'no'
     bus:lanes:forward: 'designated|'
@@ -819,6 +820,7 @@
     highway: primary
     busway: lane
     hgv: local
+    lanes: '4' # FIXME: lanes is not tagged but inferring the it is hard
     lanes:bus: '2'
     lit: 'yes'
     maxspeed: 25 mph
@@ -1078,39 +1080,67 @@
     designated: motor_vehicle
 
 - way_id: 898731283
-  comment: how should an odd number of lanes forward/backwards be split without any clues?
+  comment: guess that an odd number of lanes will be divided favouring the forward direction with a warning
+  rust:
+    ignore_warnings: true
   tags:
     highway: 'road'
     lanes: '3'
     sidewalk: 'both'
   driving_side: 'left'
   output:
-  - type: travel
-    designated: foot
-  - type: travel
-    direction: forward
-    designated: motor_vehicle
-  - type: travel
-    direction: forward
-    designated: motor_vehicle
-  - type: travel
-    direction: backward
-    designated: motor_vehicle
-  - type: travel
-    designated: foot
+    - type: travel
+      designated: foot
+    - type: travel
+      direction: forward
+      designated: motor_vehicle
+    - type: travel
+      direction: forward
+      designated: motor_vehicle
+    - type: travel
+      direction: backward
+      designated: motor_vehicle
+    - type: travel
+      designated: foot
 
 # I didn't look for a real example of this
 - description: '5 lanes'
+  comment: guess that an odd number of lanes will be divided favouring the forward direction with a warning
+  rust:
+    ignore_warnings: true
   tags:
     highway: 'road'
     lanes: '5'
     sidewalk: 'no'
   driving_side: right
+  output:
+    - type: shoulder
+    - type: travel
+      direction: backward
+      designated: motor_vehicle
+    - type: travel
+      direction: backward
+      designated: motor_vehicle
+    - type: travel
+      direction: forward
+      designated: motor_vehicle
+    - type: travel
+      direction: forward
+      designated: motor_vehicle
+    - type: travel
+      direction: forward
+      designated: motor_vehicle
+    - type: shoulder
+
+- description: assume lanes:forward to be lanes - lanes:backward
+  tags:
+    highway: secondary
+    lanes: 4
+    lanes:backward: 1
+    sidewalk: no
+  driving_side: right
   output:
   - type: shoulder
-  - type: travel
-    direction: backward
-    designated: motor_vehicle
   - type: travel
     direction: backward
     designated: motor_vehicle
@@ -1126,18 +1156,17 @@
   - type: shoulder
 
 - way_id: 335668924
+  description: a narrow alleyway tagged lanes=1
+  skip_python: true
+  skip_kotlin: true
   tags:
-    highway: 'road'
+    highway: 'service'
     lanes: '1'
-    sidewalk: 'no'
   driving_side: right
   output:
   - type: shoulder
   - type: travel
-    direction: backward
-    designated: motor_vehicle
-  - type: travel
-    direction: forward
+    direction: both
     designated: motor_vehicle
   - type: shoulder
 

rust/osm2lanes/src/test.rs

@@ -99,7 +99,7 @@ impl std::fmt::Display for TestCase {
 pub fn get_tests() -> Vec<TestCase> {
     let tests: Vec<TestCase> =
         serde_yaml::from_reader(BufReader::new(File::open("../../data/tests.yml").unwrap()))
-            .expect("invalid json");
+            .expect("invalid yaml in data/tests.yml");
     let tests: Vec<TestCase> = tests
         .into_iter()
         .filter(|test| test.test_enabled())

rust/osm2lanes/src/transform/lanes_to_tags.rs

@@ -40,21 +40,21 @@ pub fn lanes_to_tags(lanes: &[Lane], locale: &Locale, config: &LanesToTagsConfig
     let mut tags = Tags::default();
     let mut oneway = false;
     tags.checked_insert("highway", "road")?; // TODO, add `highway` to `Lanes`
-    {
-        let lane_count = lanes
-            .iter()
-            .filter(|lane| {
-                matches!(
+
+    // Lane Count
+    let lane_count = lanes
+        .iter()
+        .filter(|lane| {
+            matches!(
                     lane,
                     Lane::Travel {
                         designated: LaneDesignated::Motor | LaneDesignated::Bus,
                         ..
                     }
                 )
-            })
-            .count();
-        tags.checked_insert("lanes", lane_count.to_string())?;
-    }
+        })
+        .count();
+    tags.checked_insert("lanes", lane_count.to_string())?;
     // Oneway
     if lanes.iter().filter(|lane| lane.is_motor()).all(|lane| {
         matches!(
@@ -67,6 +67,54 @@ pub fn lanes_to_tags(lanes: &[Lane], locale: &Locale, config: &LanesToTagsConfig
     }) {
         tags.checked_insert("oneway", "yes")?;
         oneway = true;
+    } else {
+        // Forward
+        let forward_lanes = lanes
+            .iter()
+            .filter(|lane| {
+                matches!(
+                    lane,
+                    Lane::Travel {
+                        designated: LaneDesignated::Motor | LaneDesignated::Bus,
+                        direction: Some(LaneDirection::Forward),
+                        ..
+                    }
+                )
+            })
+            .count();
+        tags.checked_insert("lanes:forward", forward_lanes.to_string())?;
+        // Backward
+        let backward_lanes = lanes
+            .iter()
+            .filter(|lane| {
+                matches!(
+                    lane,
+                    Lane::Travel {
+                        designated: LaneDesignated::Motor | LaneDesignated::Bus,
+                        direction: Some(LaneDirection::Backward),
+                        ..
+                    }
+                )
+            })
+            .count();
+        tags.checked_insert("lanes:backward", backward_lanes.to_string())?;
+        // Both ways
+        if lanes.iter().any(|lane| {
+            matches!(
+            lane,
+            Lane::Travel {
+                designated: LaneDesignated::Motor,
+                direction: Some(LaneDirection::Both),
+                ..
+            }
+        )
+        }) {
+            tags.checked_insert("lanes:both_ways", "1")?;
+            // TODO: add LHT support
+            if lane_count >= 3 {
+                tags.checked_insert("turn:lanes:both_ways", "left")?;
+            }
+        }
     }
     // Shoulder
     match (
@@ -212,21 +260,6 @@ pub fn lanes_to_tags(lanes: &[Lane], locale: &Locale, config: &LanesToTagsConfig
         }
     }
 
-    if lanes.iter().any(|lane| {
-        matches!(
-            lane,
-            Lane::Travel {
-                designated: LaneDesignated::Motor,
-                direction: Some(LaneDirection::Both),
-                ..
-            }
-        )
-    }) {
-        tags.checked_insert("lanes:both_ways", "1")?;
-        // TODO: add LHT support
-        tags.checked_insert("turn:lanes:both_ways", "left")?;
-    }
-
     let max_speed = {
         let max_speeds: Vec<Speed> = lanes
             .iter()