rustfmt

amandasaurus · Feb 17, 2019 · 0015d58 · 0015d58
1 parent 2cb1a5b
commit 0015d58
Show file tree

Hide file tree

Showing 32 changed files with 56 additions and 50 deletions.
diff --git a/geo-types/src/geometry_collection.rs b/geo-types/src/geometry_collection.rs
@@ -1,5 +1,5 @@
-use std::iter::FromIterator;
 use crate::{CoordinateType, Geometry};
+use std::iter::FromIterator;
 
 /// A collection of [`Geometry`](enum.Geometry.html) types.
 ///
@@ -28,7 +28,6 @@ impl<T: CoordinateType> GeometryCollection<T> {
     }
 }
 
-
 /// Convert any Geometry (or anything that can be converted to a Geometry) into a
 /// GeometryCollection
 impl<T: CoordinateType, IG: Into<Geometry<T>>> From<IG> for GeometryCollection<T> {

diff --git a/geo-types/src/lib.rs b/geo-types/src/lib.rs
@@ -114,11 +114,11 @@ mod test {
         let _: MultiPoint<_> = vec![(0., 0.), (1., 2.)].into_iter().collect();
 
         let mut l1: LineString<_> = vec![(0., 0.), (1., 2.)].into();
-        assert_eq!(l1[1], Coordinate{ x: 1., y: 2. });   // index into linestring
+        assert_eq!(l1[1], Coordinate { x: 1., y: 2. }); // index into linestring
         let _: LineString<_> = vec![(0., 0.), (1., 2.)].into_iter().collect();
 
         // index mutably into a linestring
-        l1[0] = Coordinate{ x: 1., y: 1. };
+        l1[0] = Coordinate { x: 1., y: 1. };
         assert_eq!(l1, vec![(1., 1.), (1., 2.)].into());
     }
 

diff --git a/geo-types/src/line_string.rs b/geo-types/src/line_string.rs
@@ -1,6 +1,6 @@
+use crate::{Coordinate, CoordinateType, Line, Point, Triangle};
 use std::iter::FromIterator;
 use std::ops::{Index, IndexMut};
-use crate::{Coordinate, CoordinateType, Line, Point, Triangle};
 
 /// An ordered collection of two or more [`Coordinate`s](struct.Coordinate.html), representing a
 /// path between locations.
@@ -189,7 +189,6 @@ impl<T: CoordinateType> IndexMut<usize> for LineString<T> {
     }
 }
 
-
 #[cfg(feature = "rstar")]
 impl<T> ::rstar::RTreeObject for LineString<T>
 where

diff --git a/geo-types/src/multi_line_string.rs b/geo-types/src/multi_line_string.rs
@@ -1,5 +1,5 @@
-use std::iter::FromIterator;
 use crate::{CoordinateType, LineString};
+use std::iter::FromIterator;
 
 /// A collection of [`LineString`s](struct.LineString.html).
 ///

diff --git a/geo-types/src/multi_point.rs b/geo-types/src/multi_point.rs
@@ -1,5 +1,5 @@
-use std::iter::FromIterator;
 use crate::{CoordinateType, Point};
+use std::iter::FromIterator;
 
 /// A collection of [`Point`s](struct.Point.html).
 ///

diff --git a/geo-types/src/multi_polygon.rs b/geo-types/src/multi_polygon.rs
@@ -1,5 +1,5 @@
-use std::iter::FromIterator;
 use crate::{CoordinateType, Polygon};
+use std::iter::FromIterator;
 
 /// A collection of [`Polygon`s](struct.Polygon.html).
 ///
@@ -24,7 +24,6 @@ impl<T: CoordinateType, IP: Into<Polygon<T>>> From<Vec<IP>> for MultiPolygon<T>
     }
 }
 
-
 impl<T: CoordinateType, IP: Into<Polygon<T>>> FromIterator<IP> for MultiPolygon<T> {
     fn from_iter<I: IntoIterator<Item = IP>>(iter: I) -> Self {
         MultiPolygon(iter.into_iter().map(|p| p.into()).collect())

diff --git a/geo-types/src/point.rs b/geo-types/src/point.rs
@@ -1,8 +1,8 @@
+use crate::{Coordinate, CoordinateType};
 use num_traits::Float;
 use std::ops::Add;
 use std::ops::Neg;
 use std::ops::Sub;
-use crate::{Coordinate, CoordinateType};
 
 /// A single point in 2D space.
 ///
@@ -360,10 +360,7 @@ where
 
     const DIMENSIONS: usize = 2;
 
-    fn generate(
-        generator: impl Fn(usize) -> Self::Scalar
-    ) -> Self
-    {
+    fn generate(generator: impl Fn(usize) -> Self::Scalar) -> Self {
         Point::new(generator(0), generator(1))
     }
 

diff --git a/geo-types/src/polygon.rs b/geo-types/src/polygon.rs
@@ -1,5 +1,5 @@
-use num_traits::{Float, Signed};
 use crate::{CoordinateType, LineString, Point, Rect};
+use num_traits::{Float, Signed};
 
 /// A bounded two-dimensional area.
 ///
@@ -239,7 +239,8 @@ where
     ///
     /// [will be closed]: #linestring-closing-operation
     pub fn exterior_mut<F>(&mut self, mut f: F)
-        where F: FnMut(&mut LineString<T>)
+    where
+        F: FnMut(&mut LineString<T>),
     {
         f(&mut self.exterior);
         self.exterior.close();
@@ -348,7 +349,8 @@ where
     ///
     /// [will be closed]: #linestring-closing-operation
     pub fn interiors_mut<F>(&mut self, mut f: F)
-        where F: FnMut(&mut [LineString<T>])
+    where
+        F: FnMut(&mut [LineString<T>]),
     {
         f(&mut self.interiors);
         for interior in &mut self.interiors {

diff --git a/geo-types/src/private_utils.rs b/geo-types/src/private_utils.rs
@@ -3,8 +3,8 @@
 // hidden module is public so the geo crate can reuse these algorithms to
 // prevent duplication. These functions are _not_ meant for public consumption.
 
-use num_traits::Float;
 use crate::{Coordinate, CoordinateType, Line, LineString, Point, Rect};
+use num_traits::Float;
 
 pub static COORD_PRECISION: f32 = 1e-1; // 0.1m
 

diff --git a/geo/src/algorithm/area.rs b/geo/src/algorithm/area.rs
@@ -1,5 +1,5 @@
-use num_traits::Float;
 use crate::{CoordinateType, Line, LineString, MultiPolygon, Polygon, Rect, Triangle};
+use num_traits::Float;
 
 use crate::algorithm::winding_order::twice_signed_ring_area;
 

diff --git a/geo/src/algorithm/bearing.rs b/geo/src/algorithm/bearing.rs
@@ -1,5 +1,5 @@
-use num_traits::Float;
 use crate::Point;
+use num_traits::Float;
 
 /// Returns the bearing to another Point in degrees.
 ///

diff --git a/geo/src/algorithm/bounding_rect.rs b/geo/src/algorithm/bounding_rect.rs
@@ -1,8 +1,8 @@
-use geo_types::private_utils::{get_bounding_rect, line_string_bounding_rect};
 use crate::{
     Coordinate, CoordinateType, Line, LineString, MultiLineString, MultiPoint, MultiPolygon,
     Polygon, Rect, Triangle,
 };
+use geo_types::private_utils::{get_bounding_rect, line_string_bounding_rect};
 
 /// Calculation of the bounding rectangle of a geometry.
 pub trait BoundingRect<T: CoordinateType> {
@@ -139,7 +139,9 @@ where
 #[cfg(test)]
 mod test {
     use crate::algorithm::bounding_rect::BoundingRect;
-    use crate::{Coordinate, Line, LineString, MultiLineString, MultiPoint, MultiPolygon, Polygon, Rect};
+    use crate::{
+        Coordinate, Line, LineString, MultiLineString, MultiPoint, MultiPolygon, Polygon, Rect,
+    };
 
     #[test]
     fn empty_linestring_test() {

diff --git a/geo/src/algorithm/centroid.rs b/geo/src/algorithm/centroid.rs
@@ -306,8 +306,10 @@ where
 mod test {
     use crate::algorithm::centroid::Centroid;
     use crate::algorithm::euclidean_distance::EuclideanDistance;
+    use crate::{
+        Coordinate, Line, LineString, MultiPolygon, Point, Polygon, Rect, COORD_PRECISION,
+    };
     use num_traits::Float;
-    use crate::{Coordinate, Line, LineString, MultiPolygon, Point, Polygon, Rect, COORD_PRECISION};
 
     /// small helper to create a coordinate
     fn c<T: Float>(x: T, y: T) -> Coordinate<T> {

diff --git a/geo/src/algorithm/closest_point.rs b/geo/src/algorithm/closest_point.rs
@@ -1,7 +1,7 @@
-use num_traits::Float;
 use crate::prelude::*;
-use std::iter;
 use crate::{Closest, Line, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon};
+use num_traits::Float;
+use std::iter;
 
 /// Find the closest point between two objects, where the other object is
 /// assumed to be a `Point` by default.

diff --git a/geo/src/algorithm/contains.rs b/geo/src/algorithm/contains.rs
@@ -1,7 +1,9 @@
 use num_traits::Float;
 
 use crate::algorithm::intersects::Intersects;
-use crate::{Coordinate, CoordinateType, Line, LineString, MultiPolygon, Point, Polygon, Rect, Triangle};
+use crate::{
+    Coordinate, CoordinateType, Line, LineString, MultiPolygon, Point, Polygon, Rect, Triangle,
+};
 
 ///  Checks if the geometry A is completely inside the B geometry
 pub trait Contains<Rhs = Self> {

diff --git a/geo/src/algorithm/convexhull.rs b/geo/src/algorithm/convexhull.rs
@@ -1,8 +1,8 @@
 use crate::algorithm::euclidean_distance::EuclideanDistance;
-use num_traits::Float;
-use std::mem;
 use crate::utils::partition_slice;
 use crate::{Line, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon};
+use num_traits::Float;
+use std::mem;
 
 fn swap_remove_to_first<'a, T>(slice: &mut &'a mut [T], idx: usize) -> &'a mut T {
     let tmp = mem::replace(slice, &mut []);

diff --git a/geo/src/algorithm/euclidean_distance.rs b/geo/src/algorithm/euclidean_distance.rs
@@ -2,9 +2,11 @@ use crate::algorithm::contains::{get_position, Contains, PositionPoint};
 use crate::algorithm::euclidean_length::EuclideanLength;
 use crate::algorithm::intersects::Intersects;
 use crate::algorithm::polygon_distance_fast_path::*;
+use crate::{
+    Line, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon, Triangle,
+};
 use num_traits::float::FloatConst;
 use num_traits::{Bounded, Float, Signed};
-use crate::{Line, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon, Triangle};
 
 use rstar::RTree;
 use rstar::RTreeNum;
@@ -490,8 +492,8 @@ mod test {
     use super::*;
     use crate::algorithm::convexhull::ConvexHull;
     use crate::algorithm::euclidean_distance::EuclideanDistance;
-    use geo_types::private_utils::line_segment_distance;
     use crate::{Line, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon};
+    use geo_types::private_utils::line_segment_distance;
 
     #[test]
     fn line_segment_distance_test() {

diff --git a/geo/src/algorithm/extremes.rs b/geo/src/algorithm/extremes.rs
@@ -1,7 +1,7 @@
 use crate::algorithm::convexhull::ConvexHull;
-use num_traits::{Float, Signed};
 use crate::{ExtremePoint, Extremes};
 use crate::{MultiPoint, MultiPolygon, Point, Polygon};
+use num_traits::{Float, Signed};
 
 // Useful direction vectors, aligned with x and y axes:
 // 1., 0. = largest x

diff --git a/geo/src/algorithm/from_postgis.rs b/geo/src/algorithm/from_postgis.rs
@@ -1,9 +1,9 @@
-use postgis;
-use postgis::ewkb::{GeometryCollectionT, GeometryT};
 use crate::{
     Geometry, GeometryCollection, LineString, MultiLineString, MultiPoint, MultiPolygon, Point,
     Polygon,
 };
+use postgis;
+use postgis::ewkb::{GeometryCollectionT, GeometryT};
 
 /// Creates geometry from a PostGIS type.
 ///

diff --git a/geo/src/algorithm/haversine_destination.rs b/geo/src/algorithm/haversine_destination.rs
@@ -1,5 +1,5 @@
-use num_traits::{Float, FromPrimitive};
 use crate::{Point, MEAN_EARTH_RADIUS};
+use num_traits::{Float, FromPrimitive};
 
 /// Returns a new Point using the distance to the existing Point and a bearing for the direction
 

diff --git a/geo/src/algorithm/haversine_distance.rs b/geo/src/algorithm/haversine_distance.rs
@@ -1,5 +1,5 @@
-use num_traits::{Float, FromPrimitive};
 use crate::{Point, MEAN_EARTH_RADIUS};
+use num_traits::{Float, FromPrimitive};
 
 /// Determine the distance between two geometries using the [haversine formula].
 ///

diff --git a/geo/src/algorithm/haversine_intermediate.rs b/geo/src/algorithm/haversine_intermediate.rs
@@ -1,5 +1,5 @@
-use num_traits::{Float, FromPrimitive};
 use crate::{Point, MEAN_EARTH_RADIUS};
+use num_traits::{Float, FromPrimitive};
 
 /// Returns a new Point along a great circle route between two existing points
 

diff --git a/geo/src/algorithm/intersects.rs b/geo/src/algorithm/intersects.rs
@@ -1,6 +1,6 @@
 use crate::algorithm::contains::Contains;
-use num_traits::Float;
 use crate::{Line, LineString, Point, Polygon, Rect};
+use num_traits::Float;
 
 /// Checks if the geometry A intersects the geometry B.
 

diff --git a/geo/src/algorithm/map_coords.rs b/geo/src/algorithm/map_coords.rs
@@ -1,8 +1,8 @@
-use failure::Error;
 use crate::{
     Coordinate, CoordinateType, Geometry, GeometryCollection, Line, LineString, MultiLineString,
     MultiPoint, MultiPolygon, Point, Polygon, Rect,
 };
+use failure::Error;
 
 /// Map a function over all the coordinates in an object, returning a new one
 pub trait MapCoords<T, NT> {

diff --git a/geo/src/algorithm/polygon_distance_fast_path.rs b/geo/src/algorithm/polygon_distance_fast_path.rs
@@ -1,8 +1,8 @@
 use crate::algorithm::extremes::ExtremeIndices;
-use num_traits::float::FloatConst;
-use num_traits::{Float, Signed};
 use crate::prelude::*;
 use crate::{Line, Point, Polygon, Triangle};
+use num_traits::float::FloatConst;
+use num_traits::{Float, Signed};
 
 // These are helper functions for the "fast path" of Polygon-Polygon distance
 // They use the rotating calipers method to speed up calculations.

diff --git a/geo/src/algorithm/rotate.rs b/geo/src/algorithm/rotate.rs
@@ -1,8 +1,8 @@
 use crate::algorithm::centroid::Centroid;
 use crate::algorithm::map_coords::MapCoords;
+use crate::{Line, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon};
 use num_traits::{Float, FromPrimitive};
 use std::iter::Sum;
-use crate::{Line, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon};
 
 #[inline]
 fn rotate_inner<T>(x: T, y: T, x0: T, y0: T, sin_theta: T, cos_theta: T) -> Point<T>

diff --git a/geo/src/algorithm/simplify.rs b/geo/src/algorithm/simplify.rs
@@ -1,6 +1,6 @@
 use crate::algorithm::euclidean_distance::EuclideanDistance;
-use num_traits::Float;
 use crate::{Line, LineString, MultiLineString, MultiPolygon, Point, Polygon};
+use num_traits::Float;
 
 // Ramer–Douglas-Peucker line simplification algorithm
 fn rdp<T>(points: &[Point<T>], epsilon: &T) -> Vec<Point<T>>

diff --git a/geo/src/algorithm/simplifyvw.rs b/geo/src/algorithm/simplifyvw.rs
@@ -1,8 +1,10 @@
-use num_traits::Float;
 use crate::prelude::*;
+use crate::{
+    Coordinate, Line, LineString, MultiLineString, MultiPolygon, Point, Polygon, Triangle,
+};
+use num_traits::Float;
 use std::cmp::Ordering;
 use std::collections::BinaryHeap;
-use crate::{Coordinate, Line, LineString, MultiLineString, MultiPolygon, Point, Polygon, Triangle};
 
 use rstar::{RTree, RTreeNum};
 

diff --git a/geo/src/algorithm/to_postgis.rs b/geo/src/algorithm/to_postgis.rs
@@ -1,8 +1,8 @@
-use postgis::ewkb;
 use crate::{
     Coordinate, Geometry, GeometryCollection, Line, LineString, MultiLineString, MultiPoint,
     MultiPolygon, Point, Polygon,
 };
+use postgis::ewkb;
 
 /// Converts geometry to a PostGIS type.
 ///

diff --git a/geo/src/algorithm/vincenty_distance.rs b/geo/src/algorithm/vincenty_distance.rs
@@ -4,9 +4,9 @@
 // - https://nathanrooy.github.io/posts/2016-12-18/vincenty-formula-with-python/
 // - https://github.com/janantala/GPS-distance/blob/master/java/Distance.java
 
+use crate::{Point, EARTH_FLATTENING, EQUATORIAL_EARTH_RADIUS, POLAR_EARTH_RADIUS};
 use num_traits::{Float, FromPrimitive};
 use std::{error, fmt};
-use crate::{Point, EARTH_FLATTENING, EQUATORIAL_EARTH_RADIUS, POLAR_EARTH_RADIUS};
 
 /// Determine the distance between two geometries using [Vincenty’s formulae].
 ///

diff --git a/geo/src/algorithm/winding_order.rs b/geo/src/algorithm/winding_order.rs
@@ -1,7 +1,7 @@
-use geo_types::line_string::PointsIter;
-use std::iter::Rev;
 use crate::utils::EitherIter;
 use crate::{CoordinateType, LineString, Point};
+use geo_types::line_string::PointsIter;
+use std::iter::Rev;
 
 pub(crate) fn twice_signed_ring_area<T>(linestring: &LineString<T>) -> T
 where

diff --git a/geo/src/types.rs b/geo/src/types.rs
@@ -1,5 +1,5 @@
-use num_traits::Float;
 use crate::{CoordinateType, Point};
+use num_traits::Float;
 
 pub use geo_types::private_utils::COORD_PRECISION;