update to rust 2024

Cargo.toml

@@ -8,7 +8,7 @@ repository = "https://github.com/georust/geojson"
 readme = "README.md"
 documentation = "https://docs.rs/geojson/"
 keywords = ["geojson", "gis", "json", "geo"]
-edition = "2018"
+edition = "2024"
 
 [features]
 default = ["geo-types"]

benches/parse.rs

@@ -1,7 +1,7 @@
-use geojson::de::deserialize_geometry;
 use geojson::GeoJson;
+use geojson::de::deserialize_geometry;
 
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, black_box, criterion_group, criterion_main};
 
 use std::io::BufReader;
 

benches/serialize.rs

@@ -1,4 +1,4 @@
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, black_box, criterion_group, criterion_main};
 use geojson::{de::deserialize_geometry, ser::serialize_geometry};
 
 fn serialize_feature_collection_benchmark(c: &mut Criterion) {

benches/to_geo_types.rs

@@ -1,4 +1,4 @@
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, black_box, criterion_group, criterion_main};
 use std::convert::TryFrom;
 
 fn benchmark_group(c: &mut Criterion) {

examples/stream_reader_writer.rs

@@ -1,4 +1,4 @@
-use geojson::{de::deserialize_geometry, ser::serialize_geometry, FeatureReader, FeatureWriter};
+use geojson::{FeatureReader, FeatureWriter, de::deserialize_geometry, ser::serialize_geometry};
 
 use serde::{Deserialize, Serialize};
 use std::error::Error;

src/conversion/from_geo_types.rs

@@ -261,7 +261,7 @@ where
 #[cfg(test)]
 mod tests {
     use crate::{GeoJson, Geometry, GeometryValue};
-    use geo_types::{point, wkt, Point, Polygon};
+    use geo_types::{Point, Polygon, point, wkt};
 
     #[test]
     fn geo_point_conversion_test() {

src/conversion/to_geo_types.rs

@@ -257,16 +257,16 @@ impl<T: CoordFloat> TryFrom<&GeoJson> for geo_types::GeometryCollection<T> {
             )),
             GeoJson::Feature(feature) => {
                 if let Some(geometry) = &feature.geometry {
-                    Ok(geo_types::GeometryCollection(vec![geometry
-                        .clone()
-                        .try_into()?]))
+                    Ok(geo_types::GeometryCollection(vec![
+                        geometry.clone().try_into()?,
+                    ]))
                 } else {
                     Ok(geo_types::GeometryCollection(vec![]))
                 }
             }
-            GeoJson::Geometry(geometry) => Ok(geo_types::GeometryCollection(vec![geometry
-                .clone()
-                .try_into()?])),
+            GeoJson::Geometry(geometry) => Ok(geo_types::GeometryCollection(vec![
+                geometry.clone().try_into()?,
+            ])),
         }
     }
 }

src/errors.rs

@@ -1,6 +1,6 @@
 //! Module for all GeoJSON-related errors
-use crate::geometry::deserialize::GeometryType;
 use crate::Feature;
+use crate::geometry::deserialize::GeometryType;
 use thiserror::Error;
 
 /// Errors which can occur when encoding, decoding, and converting GeoJSON
@@ -19,7 +19,9 @@ pub enum Error {
         "Attempted to a convert a feature without a geometry into a geo_types::Geometry: `{0}`"
     )]
     FeatureHasNoGeometry(Box<Feature>),
-    #[error("Encountered geometry type: `{geometry_type}` with unexpected coordinates dimensions: {dimensions}")]
+    #[error(
+        "Encountered geometry type: `{geometry_type}` with unexpected coordinates dimensions: {dimensions}"
+    )]
     InvalidGeometryDimensions {
         geometry_type: GeometryType,
         dimensions: u8,

src/feature.rs

@@ -15,7 +15,7 @@
 use std::str::FromStr;
 
 use crate::errors::{Error, Result};
-use crate::{feature, Bbox, Geometry, GeometryValue};
+use crate::{Bbox, Geometry, GeometryValue, feature};
 use crate::{JsonObject, JsonValue};
 use serde::{Deserialize, Serialize};
 
@@ -250,7 +250,7 @@ pub enum Id {
 
 #[cfg(test)]
 mod tests {
-    use crate::{feature, Error, Feature, GeoJson, Geometry, JsonObject};
+    use crate::{Error, Feature, GeoJson, Geometry, JsonObject, feature};
     use serde_json::json;
 
     use std::str::FromStr;
@@ -354,7 +354,10 @@ mod tests {
     #[test]
     fn test_display_feature() {
         let f = feature().to_string();
-        assert_eq!(f, "{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[1.1,2.1]},\"properties\":{}}");
+        assert_eq!(
+            f,
+            "{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[1.1,2.1]},\"properties\":{}}"
+        );
     }
 
     #[test]
@@ -445,9 +448,11 @@ mod tests {
         let Error::MalformedGeoJson(serde_err) = err else {
             panic!("expected serde error");
         };
-        assert!(serde_err
-            .to_string()
-            .contains("Feature 'id' must be a string or a number"));
+        assert!(
+            serde_err
+                .to_string()
+                .contains("Feature 'id' must be a string or a number")
+        );
     }
 
     #[test]

src/feature_collection.rs

@@ -15,8 +15,8 @@
 use std::iter::FromIterator;
 use std::str::FromStr;
 
-use crate::errors::{Error, Result};
 use crate::JsonObject;
+use crate::errors::{Error, Result};
 use crate::{Bbox, Feature};
 use serde::{Deserialize, Serialize};
 

src/feature_writer.rs

@@ -41,7 +41,7 @@ impl<W: Write> FeatureWriter<W> {
             State::Finished => {
                 return Err(Error::InvalidWriterState(
                     "cannot write another Feature when writer has already finished",
-                ))
+                ));
             }
             State::New => {
                 self.write_prefix()?;
@@ -162,7 +162,7 @@ impl<W: Write> FeatureWriter<W> {
             State::Finished => {
                 return Err(Error::InvalidWriterState(
                     "cannot serialize another record when writer has already finished",
-                ))
+                ));
             }
             State::New => {
                 self.write_prefix()?;
@@ -220,7 +220,7 @@ impl<W: Write> FeatureWriter<W> {
             State::Finished => {
                 return Err(Error::InvalidWriterState(
                     "cannot finish writer - it's already finished",
-                ))
+                ));
             }
             State::New => {
                 self.state = State::Finished;

src/geojson.rs

@@ -255,7 +255,7 @@ impl fmt::Display for FeatureCollection {
 mod deserialize {
     use crate::geometry::deserialize::{Coordinates, GeometryType, RawGeometry};
     use crate::util::normalize_foreign_members;
-    use crate::{feature, Bbox, Error, Feature, FeatureCollection, GeoJson, Geometry, JsonObject};
+    use crate::{Bbox, Error, Feature, FeatureCollection, GeoJson, Geometry, JsonObject, feature};
     use serde::Deserialize;
     use std::convert::TryFrom;
 
@@ -500,7 +500,7 @@ mod tests {
     #[test]
     fn not_an_object() {
         let geojson_str = "[]";
-        let err = GeoJson::from_str(&geojson_str).unwrap_err();
+        let err = GeoJson::from_str(geojson_str).unwrap_err();
         assert!(matches!(err, Error::MalformedGeoJson(_)));
         assert!(format!("{err}").contains("expected GeoJson object"));
     }

src/geometry.rs

@@ -465,7 +465,7 @@ pub(crate) mod deserialize {
                                     Coordinates::ThreeDimensional(_) => {
                                         return Err(serde::de::Error::custom(
                                             "coordinate nesting too deep",
-                                        ))
+                                        ));
                                     }
                                 },
                             };
@@ -587,7 +587,7 @@ pub(crate) mod deserialize {
 
                 // Invalid combinations
                 (GeometryType::GeometryCollection, _, None) => {
-                    return Err(Error::GeometryCollectionWithoutGeometriesKey)
+                    return Err(Error::GeometryCollectionWithoutGeometriesKey);
                 }
 
                 (
@@ -608,7 +608,7 @@ pub(crate) mod deserialize {
                         })
                     } else {
                         Err(Error::GeometryWithoutCoordinatesKey { geometry_type })
-                    }
+                    };
                 }
             };
 
@@ -766,13 +766,15 @@ mod tests {
     #[test]
     fn test_reject_too_few_coordinates() {
         let err = Geometry::from_str(r#"{"type": "Point", "coordinates": []}"#).unwrap_err();
-        assert!(err
-            .to_string()
-            .contains("A position must contain two or more elements, but got `0`"));
+        assert!(
+            err.to_string()
+                .contains("A position must contain two or more elements, but got `0`")
+        );
 
         let err = Geometry::from_str(r#"{"type": "Point", "coordinates": [23.42]}"#).unwrap_err();
-        assert!(err
-            .to_string()
-            .contains("A position must contain two or more elements, but got `1`"));
+        assert!(
+            err.to_string()
+                .contains("A position must contain two or more elements, but got `1`")
+        );
     }
 }

src/ser.rs

@@ -98,7 +98,7 @@
 //! ```
 use crate::{Feature, JsonObject, JsonValue, Result};
 
-use serde::{ser::Error, Serialize, Serializer};
+use serde::{Serialize, Serializer, ser::Error};
 
 use serde::de::IntoDeserializer;
 use std::{convert::TryInto, io};
@@ -435,19 +435,19 @@ where
             match value {
                 JsonValue::Object(object) => object,
                 JsonValue::Null => {
-                    return Err(S::Error::custom("expected JSON object but found `null`"))
+                    return Err(S::Error::custom("expected JSON object but found `null`"));
                 }
                 JsonValue::Bool(_) => {
-                    return Err(S::Error::custom("expected JSON object but found `bool`"))
+                    return Err(S::Error::custom("expected JSON object but found `bool`"));
                 }
                 JsonValue::Number(_) => {
-                    return Err(S::Error::custom("expected JSON object but found `number`"))
+                    return Err(S::Error::custom("expected JSON object but found `number`"));
                 }
                 JsonValue::String(_) => {
-                    return Err(S::Error::custom("expected JSON object but found `string`"))
+                    return Err(S::Error::custom("expected JSON object but found `string`"));
                 }
                 JsonValue::Array(_) => {
-                    return Err(S::Error::custom("expected JSON object but found `array`"))
+                    return Err(S::Error::custom("expected JSON object but found `array`"));
                 }
             }
         };

src/util.rs

@@ -16,9 +16,9 @@ use crate::JsonObject;
 
 // Treat an empty foreign_members map as None
 pub(crate) fn normalize_foreign_members(fm: &mut Option<JsonObject>) {
-    if let Some(some_fm) = fm {
-        if some_fm.is_empty() {
-            fm.take();
-        }
+    if let Some(some_fm) = fm
+        && some_fm.is_empty()
+    {
+        fm.take();
     }
 }