fix typos

Author: jonasspinner

ARCHITECTURE.md

@@ -62,7 +62,7 @@ on the tests.
 
 Integration tests are used to test the public API.
 They are divided into two tests suite:
-- `api` contains free-standind tests
+- `api` contains freestanding tests
 - `h3` contains tests that are run against the H3 reference implementation
   (differential testing).
 

CHANGELOG.md

@@ -17,7 +17,7 @@ Possible sections are:
 ### Fixed
 
 - fix link to CHANGELOG in CONTRIBUTING
-- fix spelling in bbox
+- fix various typos
 - escape backslash in README
 
 ## [0.1.0] - 2023-01-09

fuzz/fuzz_targets/grid.rs

@@ -11,7 +11,7 @@ pub struct Args {
 }
 
 fuzz_target!(|args: Args| {
-    // Avoir overly large output (very slow, OOM risk).
+    // Avoid overly large output (very slow, OOM risk).
     if max_grid_disk_size(args.k) > 10_000 {
         return;
     }

src/coord/faceijk.rs

@@ -516,7 +516,7 @@ impl FaceIJK {
 
         // The center point is now in the same substrate grid as the origin
         // cell vertices.
-        // Add the center point substate coordinates to each vertex to translate
+        // Add the center point substrate coordinates to each vertex to translate
         // the vertices to that cell.
         for (i, vertex) in vertices.iter_mut().enumerate() {
             vertex.face = self.face;

src/coord/ijk_tests.rs

@@ -10,7 +10,7 @@ fn from_ij_zero() {
 }
 
 #[test]
-fn from_ij_rountrip() {
+fn from_ij_roundtrip() {
     for direction in Direction::iter() {
         let ijk = CoordIJK::new(0, 0, 0).neighbor(direction);
         let ij = CoordIJ::from(&ijk);
@@ -21,13 +21,13 @@ fn from_ij_rountrip() {
 }
 
 #[test]
-fn from_cube_rountrip() {
+fn from_cube_roundtrip() {
     for direction in Direction::iter() {
         let ijk = CoordIJK::new(0, 0, 0).neighbor(direction);
         let cube = CoordCube::from(ijk);
         let recovered = CoordIJK::from(cube);
 
-        assert_eq!(ijk, recovered, "rountrip for direction {direction:?}");
+        assert_eq!(ijk, recovered, "roundtrip for direction {direction:?}");
     }
 }
 

src/coord/latlng.rs

@@ -397,7 +397,7 @@ impl Eq for LatLng {}
 
 impl PartialOrd for LatLng {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        // Since our `PartialEq` use an epsilon, we must explicitely check for
+        // Since our `PartialEq` use an epsilon, we must explicitly check for
         // equality before deferring to `f64::partial_cmp`.
         if self == other {
             return Some(Ordering::Equal);

src/coord/localij.rs

@@ -7,7 +7,7 @@
 //!
 //! - local coordinates are only comparable when they have the same origin
 //!   index.
-//! - local coordinates are only valid near the origin. Pratically, this is
+//! - local coordinates are only valid near the origin. Practically, this is
 //!   within the same base cell or a neighboring base cell, except for
 //!   pentagons.
 //! - the coordinate space may have deleted or warped regions due to pentagon

src/error/hex_grid.rs

@@ -1,6 +1,6 @@
 use std::{error::Error, fmt};
 
-/// Errors related to the `IJK` coordinate system and its varians (e.g.
+/// Errors related to the `IJK` coordinate system and its variants (e.g.
 /// [`LocalIJ`](crate::LocalIJ)).
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct HexGridError {

src/geom/geometry/bbox.rs

@@ -29,7 +29,7 @@ pub fn compute_from_ring(
     for curr in ring {
         if !super::coord_is_valid(*curr) {
             return Err(InvalidGeometry::new(
-                "invalide coordinate (e.g. infinite)",
+                "invalid coordinate (e.g. infinite)",
             ));
         }
 

src/geom/geometry/ring.rs

@@ -73,7 +73,7 @@ impl<'a> Ring<'a> {
 
             // If the latitude matches exactly, we'll hit an edge case where the
             // ray passes through the vertex twice on successive segment checks.
-            // To avoid this, adjust the latiude northward if needed.
+            // To avoid this, adjust the latitude northward if needed.
             //
             // NOTE: This currently means that a point at the north pole cannot
             // be contained in any polygon. This is acceptable in current usage,

src/geom/mod.rs

@@ -5,9 +5,9 @@
 //! using radians) to make them compatible with the algorithms.
 //!
 //! The general idea here is to convert your `GeoRust` geometries before
-//! applying your H3O-related processings and, when you're done, convert back to
+//! applying your H3O-related processing and, when you're done, convert back to
 //! a `GeoRust` type.
-//! That way, you'll pay the cost of the conversion/vality check only once
+//! That way, you'll pay the cost of the conversion/validity check only once
 //! (instead of every call). Moreover, some computations can be frontloaded and
 //! cached in the wrapper type.
 

src/grid/iterator.rs

@@ -83,7 +83,7 @@ impl Iterator for DiskDistancesSafe {
 
 // -----------------------------------------------------------------------------
 
-/// Faillible, but faster, iterator over indexes within k distance of the origin.
+/// Fallible, but faster, iterator over indexes within k distance of the origin.
 pub struct DiskDistancesUnsafe {
     /// Starting point.
     origin: CellIndex,

src/index/cell.rs

@@ -167,7 +167,7 @@ const BASE_CELL: BaseCell = BaseCell::new_unchecked(2);
 /// - `C` are cells, coded on 3 bits each, with either a value in [0; 6] or the
 ///   pattern `0b111` if unused.
 ///
-/// Refrences:
+/// References:
 /// - [H3 Index Representations](https://h3geo.org/docs/core-library/h3Indexing)
 /// - [H3 Index Bit Layout](https://observablehq.com/@nrabinowitz/h3-index-bit-layout?collection=@nrabinowitz/h3)
 /// - [H3 Index Inspector](https://observablehq.com/@nrabinowitz/h3-index-inspector?collection=@nrabinowitz/h3)
@@ -884,7 +884,7 @@ impl CellIndex {
     where
         T: FromIterator<(Self, u32)>,
     {
-        // Optimistically try the faster faillible algorithm first.
+        // Optimistically try the faster fallible algorithm first.
         // If it fails, fall back to the slower always correct one.
         self.grid_disk_distances_fast(k)
             .collect::<Option<T>>()
@@ -1313,7 +1313,7 @@ impl CellIndex {
         } else {
             dir = origin_base_cell.direction(base_cell).ok_or_else(|| {
                 HexGridError::new(
-                    "cannot unfold (base cells are not neighnors)",
+                    "cannot unfold (base cells are not neighbors)",
                 )
             })?;
             base_cell
@@ -1545,7 +1545,7 @@ impl TryFrom<u64> for CellIndex {
     // Basically a simpler/faster version of `h3IsValid`.
     //
     // Simpler because here we focus only on the trailing 56-bit part.
-    // Faster because no loops, just plain ol' bitwise operationss :)
+    // Faster because no loops, just plain ol' bitwise operations :)
     fn try_from(value: u64) -> Result<Self, Self::Error> {
         if (value >> 56) & 0b1000_0111 != 0 {
             return Err(Self::Error::new(Some(value), "tainted reserved bits"));

src/index/edge.rs

@@ -91,7 +91,7 @@ impl fmt::Display for Edge {
 /// - `E` is the edge of the origin cell, in [1; 6], coded on 3 bits (56-58).
 /// - `O` is the origin cell index, coded on 56 bits (0-55).
 ///
-/// Refrences:
+/// References:
 /// - [H3 Index Representations](https://h3geo.org/docs/core-library/h3Indexing)
 /// - [H3 Index Bit Layout](https://observablehq.com/@nrabinowitz/h3-index-bit-layout?collection=@nrabinowitz/h3)
 /// - [H3 Index Inspector](https://observablehq.com/@nrabinowitz/h3-index-inspector?collection=@nrabinowitz/h3)

src/index/iterator.rs

@@ -126,7 +126,7 @@ fn get_starting_state(index: CellIndex, resolution: Resolution) -> u64 {
     // If we have resolution between current and targeted one we clear their
     // directions.
     if range != 0 {
-        // Mask with the righ number of bit to cover the directions.
+        // Mask with the right number of bit to cover the directions.
         let mask = (1 << (range * DIRECTION_BITSIZE)) - 1;
         // Mask offset required to clear the directions.
         let offset = resolution.direction_offset();

src/index/vertex.rs

@@ -138,7 +138,7 @@ impl<'a> arbitrary::Arbitrary<'a> for Vertex {
 ///   (56-58).
 /// - `O` is the owner cell index, coded on 56 bits (0-55).
 ///
-/// Refrences:
+/// References:
 /// - [H3 Index Representations](https://h3geo.org/docs/core-library/h3Indexing)
 /// - [H3 Index Bit Layout](https://observablehq.com/@nrabinowitz/h3-index-bit-layout?collection=@nrabinowitz/h3)
 /// - [H3 Index Inspector](https://observablehq.com/@nrabinowitz/h3-index-inspector?collection=@nrabinowitz/h3)

src/resolution.rs

@@ -445,7 +445,7 @@ impl<'a> arbitrary::Arbitrary<'a> for Resolution {
 
 /// Same as an H3 index resolution, but can goes up to 16.
 ///
-/// This extented range is required for some intermediate calculation.
+/// This extended range is required for some intermediate calculation.
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
 pub struct ExtendedResolution(u8);
 

tests/h3/cell_to_latlng.rs

@@ -36,7 +36,7 @@ test!(res13, 0x8d1fb46622d85bf);
 test!(res14, 0x8e1fb46622d8597);
 test!(res15, 0x8f1fb46622d8591);
 
-// Those ones triggered a bug where longitude wheren't in the right bounds.
+// Those ones triggered a bug where longitude weren't in the right bounds.
 test!(bound_bug1, 0x8400481ffffffff);
 test!(bound_bug2, 0x8471921ffffffff);