Bump the version to 0.2.1

In rustdoc, the crate's own types don't need to be linked, but for some
web view that uses plain Markdown, the links looked weird. Fix this by
linkin the crates' own types too.

CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.1] - 2023-03-11
+
+### Changed
+
+* Bumped dependency on `derive_builder` crate
+* Use `assert_eq` for float tests; drop dev depend on `float_eq` crate
+
+### Fixed
+
+* Fix doclinks in README
+* Fix docs.rs metadata section name in `Cargo.toml`
+
 ## [0.2.0] - 2022-10-01
 
 ### Added
@@ -30,6 +42,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 * Fix some small errors in the documentation
 
-[Unreleased]: https://git.luon.net/paul/geo-uri-rs/compare/v0.2.0...HEAD
+[Unreleased]: https://git.luon.net/paul/geo-uri-rs/compare/v0.2.1...HEAD
+[0.2.1]: https://git.luon.net/paul/geo-uri-rs/compare/v0.2.0..v0.2.1
 [0.2.0]: https://git.luon.net/paul/geo-uri-rs/compare/v0.1.1..v0.2.0
 [0.1.1]: https://git.luon.net/paul/geo-uri-rs/commits/tag/v0.1.1

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "geo-uri"
-version = "0.2.0"
+version = "0.2.1"
 authors = ["Paul van Tilburg <paul@luon.net>"]
 edition = "2021"
 rust-version = "1.60.0"
@@ -11,7 +11,7 @@ license = "MIT"
 keywords = ["geolocation", "uri", "parser", "rfc5870"]
 categories = ["parser-implementations", "web-programming", "encoding"]
 
-[package.metadata.docs.rs]
+[package.metadata."docs.rs"]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
@@ -20,11 +20,10 @@ url = ["dep:url"]
 serde = ["dep:serde"]
 
 [dependencies]
-derive_builder = "0.11.2"
+derive_builder = "0.12.0"
 serde = { version = "1.0.145", optional = true }
 thiserror = "1.0.35"
 url = { version = "2.3.1", optional = true }
 
 [dev-dependencies]
-float_eq = "1.0.0"
 serde_test = "1.0.145"

README.md

@@ -24,7 +24,7 @@ $ cargo add geo-uri
 
 Use either the [`TryFrom`](std::convert::TryFrom) trait or the
 [`parse`](str::parse) method on strings to parse a geo URI string into a
-[`GeoUri`] struct:
+[`GeoUri`](GeoUri) struct:
 
 ```rust
 use geo_uri::GeoUri;
@@ -56,8 +56,8 @@ assert_eq!(geo_uri.uncertainty(), None);
 
 ### Generating
 
-Use the [`GeoUriBuilder`] to construct a [`GeoUri`] struct.
-Then, use either the [`ToString`](std::string::ToString) or
+Use the [`GeoUriBuilder`](GeoUriBuilder) to construct a [`GeoUri`](GeoUri)
+struct. Then, use either the [`ToString`](std::string::ToString) or
 [`Display`](std::fmt::Display) trait to generate a geo URI string:
 
 ```rust
@@ -80,8 +80,8 @@ assert_eq!(
 );
 ```
 
-It is also possible to construct a [`GeoUri`] struct from coordinate tuples
-using the [`TryFrom`](std::convert::TryFrom) trait:
+It is also possible to construct a [`GeoUri`](GeoUri) struct from coordinate
+tuples using the [`TryFrom`](std::convert::TryFrom) trait:
 
 ```rust
 use geo_uri::GeoUri;
@@ -115,13 +115,14 @@ let geo_url = Url::from(geo_uri);
 assert_eq!(url, geo_url);
 ```
 
-Note that it is always possible to transform a [`GeoUri`] into an [`Url`], but
-not always the other way around! This is because the format of the coordinates
-and parameters after the URI scheme "geo:" may be invalid!
+Note that it is always possible to transform a [`GeoUri`](GeoUri) into an
+[`Url`](https://docs.rs/url/2/url/struct.Url.html), but not always the other
+way around! This is because the format of the coordinates and parameters after
+the URI scheme "geo:" may be invalid!
 
 ### Feature: `serde`
 
-If you enable the `serde` feature, [`GeoUri`] will implement
+If you enable the `serde` feature, [`GeoUri`](GeoUri) will implement
 [`serde::Serialize`](https://docs.rs/serde/1/serde/trait.Serialize.html) and
 [`serde::Deserialize`](https://docs.rs/serde/1/serde/trait.Deserialize.html).
 See the [serde](https://serde.rs) documentation for more information.

src/lib.rs

@@ -624,7 +624,6 @@ impl GeoUriBuilder {
 
 #[cfg(test)]
 mod tests {
-    use float_eq::assert_float_eq;
     #[cfg(feature = "serde")]
     use serde_test::{assert_de_tokens_error, assert_tokens, Token};
 
@@ -662,8 +661,8 @@ mod tests {
 
         builder.longitude(5.134);
         let geo_uri = builder.build()?;
-        assert_float_eq!(geo_uri.latitude, 52.107, abs <= 0.001);
-        assert_float_eq!(geo_uri.longitude, 5.134, abs <= 0.001);
+        assert_eq!(geo_uri.latitude, 52.107);
+        assert_eq!(geo_uri.longitude, 5.134);
         assert_eq!(geo_uri.altitude, None);
         assert_eq!(geo_uri.uncertainty, None);
 
@@ -691,8 +690,8 @@ mod tests {
     #[test]
     fn geo_uri_parse() -> Result<(), Error> {
         let geo_uri = GeoUri::parse("geo:52.107,5.134")?;
-        assert_float_eq!(geo_uri.latitude, 52.107, abs <= 0.001);
-        assert_float_eq!(geo_uri.longitude, 5.134, abs <= 0.001);
+        assert_eq!(geo_uri.latitude, 52.107);
+        assert_eq!(geo_uri.longitude, 5.134);
         assert_eq!(geo_uri.altitude, None);
         assert_eq!(geo_uri.uncertainty, None);
 
@@ -727,9 +726,9 @@ mod tests {
         assert!(matches!(geo_uri, Err(Error::InvalidCoord(_))));
 
         let geo_uri = GeoUri::parse("geo:52.107,5.134,3.6")?;
-        assert_float_eq!(geo_uri.latitude, 52.107, abs <= 0.001);
-        assert_float_eq!(geo_uri.longitude, 5.134, abs <= 0.001);
-        assert_float_eq!(geo_uri.altitude.unwrap(), 3.6, abs <= 0.1);
+        assert_eq!(geo_uri.latitude, 52.107);
+        assert_eq!(geo_uri.longitude, 5.134);
+        assert_eq!(geo_uri.altitude.unwrap(), 3.6);
         assert_eq!(geo_uri.uncertainty, None);
 
         let geo_uri = GeoUri::parse("geo:52.107,5.34,3.6;u=");
@@ -745,24 +744,24 @@ mod tests {
         assert!(matches!(geo_uri, Err(Error::OutOfRangeUncertainty)));
 
         let geo_uri = GeoUri::parse("geo:52.107,5.134,3.6;u=25000")?;
-        assert_float_eq!(geo_uri.latitude, 52.107, abs <= 0.001);
-        assert_float_eq!(geo_uri.longitude, 5.134, abs <= 0.001);
-        assert_float_eq!(geo_uri.altitude.unwrap(), 3.6, abs <= 0.1);
+        assert_eq!(geo_uri.latitude, 52.107);
+        assert_eq!(geo_uri.longitude, 5.134);
+        assert_eq!(geo_uri.altitude.unwrap(), 3.6);
         assert_eq!(geo_uri.uncertainty, Some(25_000.0));
 
         let geo_uri = GeoUri::parse("geo:52.107,5.134,3.6;crs=wgs84;u=25000")?;
-        assert_float_eq!(geo_uri.latitude, 52.107, abs <= 0.001);
-        assert_float_eq!(geo_uri.longitude, 5.134, abs <= 0.001);
-        assert_float_eq!(geo_uri.altitude.unwrap(), 3.6, abs <= 0.1);
+        assert_eq!(geo_uri.latitude, 52.107);
+        assert_eq!(geo_uri.longitude, 5.134);
+        assert_eq!(geo_uri.altitude.unwrap(), 3.6);
         assert_eq!(geo_uri.uncertainty, Some(25_000.0));
 
         let geo_uri = GeoUri::parse("geo:52.107,5.134,3.6;CRS=wgs84;U=25000")?;
         assert_eq!(geo_uri.uncertainty, Some(25_000.0));
 
         let geo_uri = GeoUri::parse("geo:52.107,5.134,3.6;crs=wgs84;u=25000;foo=bar")?;
-        assert_float_eq!(geo_uri.latitude, 52.107, abs <= 0.001);
-        assert_float_eq!(geo_uri.longitude, 5.134, abs <= 0.001);
-        assert_float_eq!(geo_uri.altitude.unwrap(), 3.6, abs <= 0.1);
+        assert_eq!(geo_uri.latitude, 52.107);
+        assert_eq!(geo_uri.longitude, 5.134);
+        assert_eq!(geo_uri.altitude.unwrap(), 3.6);
         assert_eq!(geo_uri.uncertainty, Some(25_000.0));
 
         let geo_uri = GeoUri::parse("geo:52.107,5.34,3.6;crs=foo");
@@ -773,21 +772,21 @@ mod tests {
 
         // Examples from RFC 5870 (sections 1, 6.1, 6.2 and 9.4)!
         let geo_uri = GeoUri::parse("geo:13.4125,103.8667")?;
-        assert_float_eq!(geo_uri.latitude, 13.4125, abs <= 0.0001);
-        assert_float_eq!(geo_uri.longitude, 103.8667, abs <= 0.0001);
+        assert_eq!(geo_uri.latitude, 13.4125);
+        assert_eq!(geo_uri.longitude, 103.8667);
         assert_eq!(geo_uri.altitude, None);
         assert_eq!(geo_uri.uncertainty, None);
 
         let geo_uri = GeoUri::parse("geo:48.2010,16.3695,183")?;
-        assert_float_eq!(geo_uri.latitude, 48.2010, abs <= 0.0001);
-        assert_float_eq!(geo_uri.longitude, 16.3695, abs <= 0.0001);
-        assert_float_eq!(geo_uri.altitude.unwrap(), 183.0, abs <= 0.1);
+        assert_eq!(geo_uri.latitude, 48.2010);
+        assert_eq!(geo_uri.longitude, 16.3695);
+        assert_eq!(geo_uri.altitude.unwrap(), 183.0);
         assert_eq!(geo_uri.uncertainty, None);
 
         let geo_uri = GeoUri::parse("geo:48.198634,16.371648;crs=wgs84;u=40")?;
         assert_eq!(geo_uri.crs, CoordRefSystem::Wgs84);
-        assert_float_eq!(geo_uri.latitude, 48.198634, abs <= 0.000001);
-        assert_float_eq!(geo_uri.longitude, 16.371648, abs <= 0.000001);
+        assert_eq!(geo_uri.latitude, 48.198634);
+        assert_eq!(geo_uri.longitude, 16.371648);
         assert_eq!(geo_uri.altitude, None);
         assert_eq!(geo_uri.uncertainty, Some(40.0));
 
@@ -896,8 +895,8 @@ mod tests {
     #[test]
     fn geo_uri_from_str() -> Result<(), Error> {
         let geo_uri = GeoUri::from_str("geo:52.107,5.134")?;
-        assert_float_eq!(geo_uri.latitude, 52.107, abs <= 0.001);
-        assert_float_eq!(geo_uri.longitude, 5.134, abs <= 0.001);
+        assert_eq!(geo_uri.latitude, 52.107);
+        assert_eq!(geo_uri.longitude, 5.134);
         assert_eq!(geo_uri.altitude, None);
         assert_eq!(geo_uri.uncertainty, None);
 
@@ -930,15 +929,15 @@ mod tests {
     fn geo_uri_try_from() -> Result<(), Error> {
         // &str
         let geo_uri = GeoUri::try_from("geo:52.107,5.134")?;
-        assert_float_eq!(geo_uri.latitude, 52.107, abs <= 0.001);
-        assert_float_eq!(geo_uri.longitude, 5.134, abs <= 0.001);
+        assert_eq!(geo_uri.latitude, 52.107);
+        assert_eq!(geo_uri.longitude, 5.134);
         assert_eq!(geo_uri.altitude, None);
         assert_eq!(geo_uri.uncertainty, None);
 
         // (f64, f64)
         let geo_uri = GeoUri::try_from((51.107, 5.134))?;
-        assert_float_eq!(geo_uri.latitude, 51.107, abs <= 0.001);
-        assert_float_eq!(geo_uri.longitude, 5.134, abs <= 0.001);
+        assert_eq!(geo_uri.latitude, 51.107);
+        assert_eq!(geo_uri.longitude, 5.134);
         assert_eq!(geo_uri.altitude, None);
         assert_eq!(geo_uri.uncertainty, None);
 
@@ -953,9 +952,9 @@ mod tests {
 
         // (f64, f64, f64)
         let geo_uri = GeoUri::try_from((51.107, 5.134, 3.6))?;
-        assert_float_eq!(geo_uri.latitude, 51.107, abs <= 0.001);
-        assert_float_eq!(geo_uri.longitude, 5.134, abs <= 0.001);
-        assert_float_eq!(geo_uri.altitude.unwrap(), 3.6, abs <= 0.1);
+        assert_eq!(geo_uri.latitude, 51.107);
+        assert_eq!(geo_uri.longitude, 5.134);
+        assert_eq!(geo_uri.altitude.unwrap(), 3.6);
         assert_eq!(geo_uri.uncertainty, None);
 
         assert_eq!(
@@ -976,15 +975,15 @@ mod tests {
         // Url
         let url = Url::parse("geo:51.107,5.134,3.6;crs=wgs84;u=1000;foo=bar").expect("valid URL");
         let geo_uri = GeoUri::try_from(&url)?;
-        assert_float_eq!(geo_uri.latitude, 51.107, abs <= 0.001);
-        assert_float_eq!(geo_uri.longitude, 5.134, abs <= 0.001);
-        assert_float_eq!(geo_uri.altitude.unwrap(), 3.6, abs <= 0.1);
+        assert_eq!(geo_uri.latitude, 51.107);
+        assert_eq!(geo_uri.longitude, 5.134);
+        assert_eq!(geo_uri.altitude.unwrap(), 3.6);
         assert_eq!(geo_uri.uncertainty, Some(1000.0));
 
         let geo_uri = GeoUri::try_from(url)?;
-        assert_float_eq!(geo_uri.latitude, 51.107, abs <= 0.001);
-        assert_float_eq!(geo_uri.longitude, 5.134, abs <= 0.001);
-        assert_float_eq!(geo_uri.altitude.unwrap(), 3.6, abs <= 0.1);
+        assert_eq!(geo_uri.latitude, 51.107);
+        assert_eq!(geo_uri.longitude, 5.134);
+        assert_eq!(geo_uri.altitude.unwrap(), 3.6);
         assert_eq!(geo_uri.uncertainty, Some(1000.0));
 
         Ok(())