Split of "#111 Fix lane count calculation"

data/tests.yml

@@ -847,9 +847,10 @@
   rust: false # see next test
   tags:
     highway: "road"
-    lanes: "3"
     sidewalk: "no"
     shoulder: "no"
+    lanes: "3"
+    lanes:forward: "2"
     bus:lanes:forward: "designated|"
   driving_side: right
   road:
@@ -1079,6 +1080,8 @@
 
 - way_id: 389654080
   mapillary: https://www.mapillary.com/app/?pKey=331760328316020
+  rust:
+    expect_warnings: true # deprecated centre_turn_lane
   # TODO: the cycleway is actually two marked lanes,
   # how should we know that given the tags or what should the tags be?
   tags:
@@ -1185,6 +1188,8 @@
 - description: "3 lanes"
   way_id: 898731283
   comment: "guess that an odd number of lanes will be divided favouring the forward direction with a warning"
+  rust:
+    expect_warnings: true
   tags:
     highway: "road"
     lanes: "3"
@@ -1210,6 +1215,8 @@
 # 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:
+    expect_warnings: true
   tags:
     highway: "road"
     lanes: "5"
@@ -1238,7 +1245,6 @@
 
 - description: "lanes, lanes:backward"
   comment: "assume lanes:forward to be lanes - lanes:backward"
-  rust: false
   skip_python: true
   skip_kotlin: true
   tags:

rust/osm2lanes/src/locale.rs

@@ -171,6 +171,15 @@ impl std::str::FromStr for DrivingSide {
     }
 }
 
+impl ToString for DrivingSide {
+    fn to_string(&self) -> String {
+        match self {
+            Self::Right => String::from("right"),
+            Self::Left => String::from("left"),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use celes::Country;

rust/osm2lanes/src/tag/mod.rs

@@ -11,6 +11,8 @@ pub use key::TagKey;
 mod osm;
 pub use osm::{Highway, HighwayType, Lifecycle, HIGHWAY, LIFECYCLE};
 
+use crate::transform::{RoadWarnings, TagsToLanesMsg};
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DuplicateKeyError(String);
 
@@ -90,6 +92,26 @@ impl Tags {
         self.map.get(k.as_ref()).map(String::as_str)
     }
 
+    /// Get the value for the given key and parse it into T.
+    /// Add a `TagsToLanesMsg::Unsupported` if parsing fails.
+    pub fn get_parsed<K: AsRef<str>, T: FromStr>(
+        &self,
+        key: K,
+        warnings: &mut RoadWarnings,
+    ) -> Option<T> {
+        self.get(&key).and_then(|val| {
+            if let Ok(n) = val.parse::<T>() {
+                Some(n)
+            } else {
+                warnings.push(TagsToLanesMsg::unsupported_tag(
+                    key.as_ref().to_owned(),
+                    val,
+                ));
+                None
+            }
+        })
+    }
+
     /// Return if tags key has value,
     /// return false if key does not exist.
     #[must_use]

rust/osm2lanes/src/test.rs

@@ -125,7 +125,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/mod.rs

@@ -157,17 +157,15 @@ pub fn lanes_to_tags(
 
     let lanes = &road.lanes;
 
-    set_lanes(lanes, &mut tags)?;
-    let oneway = set_oneway(lanes, &mut tags)?;
+    let lane_count = set_lanes(lanes, &mut tags)?;
+    let oneway = set_oneway(lanes, &mut tags, locale, lane_count)?;
 
     set_shoulder(lanes, &mut tags)?;
     set_pedestrian(lanes, &mut tags)?;
     set_parking(lanes, &mut tags)?;
     set_cycleway(lanes, &mut tags, oneway)?;
     set_busway(lanes, &mut tags, oneway)?;
 
-    lanes_both_ways(lanes, &mut tags)?;
-
     let max_speed = get_max_speed(lanes, &mut tags)?;
 
     locale_additions(max_speed, locale, &mut tags)?;
@@ -177,7 +175,7 @@ pub fn lanes_to_tags(
     Ok(tags)
 }
 
-fn set_lanes(lanes: &[Lane], tags: &mut Tags) -> Result<(), LanesToTagsMsg> {
+fn set_lanes(lanes: &[Lane], tags: &mut Tags) -> Result<usize, LanesToTagsMsg> {
     let lane_count = lanes
         .iter()
         .filter(|lane| {
@@ -191,11 +189,16 @@ fn set_lanes(lanes: &[Lane], tags: &mut Tags) -> Result<(), LanesToTagsMsg> {
         })
         .count();
     tags.checked_insert("lanes", lane_count.to_string())?;
-    Ok(())
+    Ok(lane_count)
 }
 
 /// Returns oneway
-fn set_oneway(lanes: &[Lane], tags: &mut Tags) -> Result<bool, LanesToTagsMsg> {
+fn set_oneway(
+    lanes: &[Lane],
+    tags: &mut Tags,
+    locale: &Locale,
+    lane_count: usize,
+) -> Result<bool, LanesToTagsMsg> {
     if lanes.iter().filter(|lane| lane.is_motor()).all(|lane| {
         matches!(
             lane,
@@ -208,6 +211,55 @@ fn set_oneway(lanes: &[Lane], tags: &mut Tags) -> Result<bool, LanesToTagsMsg> {
         tags.checked_insert("oneway", "yes")?;
         Ok(true)
     } else {
+        // Forward
+        let forward_lanes = lanes
+            .iter()
+            .filter(|lane| {
+                matches!(
+                    lane,
+                    Lane::Travel {
+                        designated: Designated::Motor | Designated::Bus,
+                        direction: Some(Direction::Forward),
+                        ..
+                    }
+                )
+            })
+            .count();
+        tags.checked_insert("lanes:forward", forward_lanes.to_string())?;
+        // Backward
+        let backward_lanes = lanes
+            .iter()
+            .filter(|lane| {
+                matches!(
+                    lane,
+                    Lane::Travel {
+                        designated: Designated::Motor | Designated::Bus,
+                        direction: Some(Direction::Backward),
+                        ..
+                    }
+                )
+            })
+            .count();
+        tags.checked_insert("lanes:backward", backward_lanes.to_string())?;
+        // Both ways
+        if lanes.iter().any(|lane| {
+            matches!(
+                lane,
+                Lane::Travel {
+                    designated: Designated::Motor,
+                    direction: Some(Direction::Both),
+                    ..
+                }
+            )
+        }) {
+            tags.checked_insert("lanes:both_ways", "1")?;
+            if lane_count >= 3 {
+                tags.checked_insert(
+                    "turn:lanes:both_ways",
+                    locale.driving_side.opposite().to_string(),
+                )?;
+            }
+        }
         Ok(false)
     }
 }
@@ -361,24 +413,6 @@ fn set_busway(lanes: &[Lane], tags: &mut Tags, oneway: bool) -> Result<(), Lanes
     Ok(())
 }
 
-fn lanes_both_ways(lanes: &[Lane], tags: &mut Tags) -> Result<(), LanesToTagsMsg> {
-    if lanes.iter().any(|lane| {
-        matches!(
-            lane,
-            Lane::Travel {
-                designated: Designated::Motor,
-                direction: Some(Direction::Both),
-                ..
-            }
-        )
-    }) {
-        tags.checked_insert("lanes:both_ways", "1")?;
-        // TODO: add LHT support
-        tags.checked_insert("turn:lanes:both_ways", "left")?;
-    }
-    Ok(())
-}
-
 fn get_max_speed(lanes: &[Lane], tags: &mut Tags) -> Result<Option<Speed>, LanesToTagsMsg> {
     let max_speeds: Vec<Speed> = lanes
         .iter()

rust/osm2lanes/src/transform/mod.rs

@@ -5,7 +5,7 @@ use crate::tag::TagKey;
 mod error;
 pub use error::{RoadError, RoadFromTags, RoadWarnings};
 
-mod tags_to_lanes;
+pub mod tags_to_lanes;
 pub use tags_to_lanes::{tags_to_lanes, Config as TagsToLanesConfig, TagsToLanesMsg};
 
 mod lanes_to_tags;