Upgrade to 2018

sfackler · sfackler · commit c68b66f93755 · 2020-01-12T16:07:44.000-08:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -2,6 +2,7 @@
 name = "postgres_array"
 version = "0.9.0"
 authors = ["Steven Fackler <sfackler@gmail.com>"]
+edition = "2018"
 license = "MIT"
 description = "Array support for rust-postgres"
 repository = "https://github.com/sfackler/rust-postgres-array"
diff --git a/src/array.rs b/src/array.rs
@@ -1,9 +1,9 @@
+use std::fmt;
 use std::ops::{Index, IndexMut};
 use std::slice;
 use std::vec;
-use std::fmt;
 
-use Dimension;
+use crate::Dimension;
 
 /// A multi-dimensional array.
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -13,17 +13,17 @@ pub struct Array<T> {
 }
 
 impl<T: fmt::Display> fmt::Display for Array<T> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         if self.dims.iter().any(|dim| dim.lower_bound != 1) {
             for dim in &self.dims {
-                try!(write!(
+                write!(
                     fmt,
                     "[{}:{}]",
                     dim.lower_bound,
                     dim.lower_bound + dim.len - 1
-                ));
+                )?;
             }
-            try!(write!(fmt, "="));
+            write!(fmt, "=")?;
         }
         fmt_helper(0, &self.dims, &mut self.data.iter(), fmt)
     }
@@ -32,8 +32,8 @@ impl<T: fmt::Display> fmt::Display for Array<T> {
 fn fmt_helper<'a, T, I>(
     depth: usize,
     dims: &[Dimension],
-    mut data: &mut I,
-    fmt: &mut fmt::Formatter,
+    data: &mut I,
+    fmt: &mut fmt::Formatter<'_>,
 ) -> fmt::Result
 where
     I: Iterator<Item = &'a T>,
@@ -43,12 +43,12 @@ where
         return write!(fmt, "{}", data.next().unwrap());
     }
 
-    try!(write!(fmt, "{{"));
+    write!(fmt, "{{")?;
     for i in 0..dims[depth].len {
         if i != 0 {
-            try!(write!(fmt, ","));
+            write!(fmt, ",")?;
         }
-        try!(fmt_helper(depth + 1, dims, data, fmt));
+        fmt_helper(depth + 1, dims, data, fmt)?;
     }
     write!(fmt, "}}")
 }
@@ -65,26 +65,24 @@ impl<T> Array<T> {
     /// elements specified by the dimensions.
     pub fn from_parts(data: Vec<T>, dimensions: Vec<Dimension>) -> Array<T> {
         assert!(
-            (data.is_empty() && dimensions.is_empty()) ||
-                data.len() as i32 == dimensions.iter().fold(1, |acc, i| acc * i.len),
+            (data.is_empty() && dimensions.is_empty())
+                || data.len() as i32 == dimensions.iter().fold(1, |acc, i| acc * i.len),
             "size mismatch"
         );
         Array {
             dims: dimensions,
-            data: data,
+            data,
         }
     }
 
     /// Creates a new one-dimensional array.
     pub fn from_vec(data: Vec<T>, lower_bound: i32) -> Array<T> {
         Array {
-            dims: vec![
-                Dimension {
-                    len: data.len() as i32,
-                    lower_bound: lower_bound,
-                },
-            ],
-            data: data,
+            dims: vec![Dimension {
+                len: data.len() as i32,
+                lower_bound,
+            }],
+            data,
         }
     }
 
@@ -97,7 +95,7 @@ impl<T> Array<T> {
             0,
             Dimension {
                 len: 1,
-                lower_bound: lower_bound,
+                lower_bound,
             },
         );
     }
@@ -147,14 +145,18 @@ impl<T> Array<T> {
 
     /// Returns an iterator over references to the elements of the array in the
     /// higher-dimensional equivalent of row-major order.
-    pub fn iter<'a>(&'a self) -> Iter<'a, T> {
-        Iter { inner: self.data.iter() }
+    pub fn iter(&self) -> Iter<'_, T> {
+        Iter {
+            inner: self.data.iter(),
+        }
     }
 
     /// Returns an iterator over mutable references to the elements of the
     /// array in the higher-dimensional equivalent of row-major order.
-    pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T> {
-        IterMut { inner: self.data.iter_mut() }
+    pub fn iter_mut(&mut self) -> IterMut<'_, T> {
+        IterMut {
+            inner: self.data.iter_mut(),
+        }
     }
 
     /// Returns the underlying data vector for this Array in the
@@ -293,13 +295,15 @@ impl<T> IntoIterator for Array<T> {
     type IntoIter = IntoIter<T>;
 
     fn into_iter(self) -> IntoIter<T> {
-        IntoIter { inner: self.data.into_iter() }
+        IntoIter {
+            inner: self.data.into_iter(),
+        }
     }
 }
 
 /// An iterator over references to values of an `Array` in the
 /// higher-dimensional equivalent of row-major order.
-pub struct Iter<'a, T: 'a> {
+pub struct Iter<'a, T> {
     inner: slice::Iter<'a, T>,
 }
 
@@ -329,7 +333,7 @@ impl<'a, T: 'a> ExactSizeIterator for Iter<'a, T> {
 
 /// An iterator over mutable references to values of an `Array` in the
 /// higher-dimensional equivalent of row-major order.
-pub struct IterMut<'a, T: 'a> {
+pub struct IterMut<'a, T> {
     inner: slice::IterMut<'a, T>,
 }
 
diff --git a/src/impls.rs b/src/impls.rs
@@ -1,41 +1,36 @@
 use fallible_iterator::FallibleIterator;
-use postgres_shared::types::{Type, Kind, ToSql, FromSql, IsNull};
-use postgres_protocol::types;
 use postgres_protocol;
+use postgres_protocol::types;
+use postgres_shared::to_sql_checked;
+use postgres_shared::types::{FromSql, IsNull, Kind, ToSql, Type};
 use std::error::Error;
 
-use {Array, Dimension};
+use crate::{Array, Dimension};
 
 impl<T> FromSql for Array<T>
 where
     T: FromSql,
 {
-    fn from_sql(ty: &Type, raw: &[u8]) -> Result<Array<T>, Box<Error + Sync + Send>> {
+    fn from_sql(ty: &Type, raw: &[u8]) -> Result<Array<T>, Box<dyn Error + Sync + Send>> {
         let element_type = match *ty.kind() {
             Kind::Array(ref ty) => ty,
             _ => unreachable!(),
         };
 
-        let array = try!(types::array_from_sql(raw));
-
-        let dimensions = try!(
-            array
-                .dimensions()
-                .map(|d| {
-                    Dimension {
-                        len: d.len,
-                        lower_bound: d.lower_bound,
-                    }
-                })
-                .collect()
-        );
+        let array = types::array_from_sql(raw)?;
 
-        let elements = try!(
-            array
-                .values()
-                .and_then(|v| FromSql::from_sql_nullable(element_type, v))
-                .collect()
-        );
+        let dimensions = array
+            .dimensions()
+            .map(|d| Dimension {
+                len: d.len,
+                lower_bound: d.lower_bound,
+            })
+            .collect()?;
+
+        let elements = array
+            .values()
+            .and_then(|v| FromSql::from_sql_nullable(element_type, v))
+            .collect()?;
 
         Ok(Array::from_parts(elements, dimensions))
     }
@@ -52,21 +47,19 @@ impl<T> ToSql for Array<T>
 where
     T: ToSql,
 {
-    fn to_sql(&self, ty: &Type, w: &mut Vec<u8>) -> Result<IsNull, Box<Error + Sync + Send>> {
+    fn to_sql(&self, ty: &Type, w: &mut Vec<u8>) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
         let element_type = match ty.kind() {
             &Kind::Array(ref ty) => ty,
             _ => unreachable!(),
         };
 
-        let dimensions = self.dimensions().iter().map(|d| {
-            types::ArrayDimension {
-                len: d.len,
-                lower_bound: d.lower_bound,
-            }
+        let dimensions = self.dimensions().iter().map(|d| types::ArrayDimension {
+            len: d.len,
+            lower_bound: d.lower_bound,
         });
         let elements = self.iter();
 
-        try!(types::array_to_sql(
+        types::array_to_sql(
             dimensions,
             true,
             element_type.oid(),
@@ -77,7 +70,7 @@ where
                 Err(e) => Err(e),
             },
             w,
-        ));
+        )?;
 
         Ok(IsNull::No)
     }
@@ -96,18 +89,19 @@ where
 mod test {
     use std::fmt;
 
-    use postgres::{Connection, TlsMode};
+    use crate::Array;
     use postgres::types::{FromSql, ToSql};
-    use Array;
+    use postgres::{Connection, TlsMode};
 
     fn test_type<T: PartialEq + FromSql + ToSql, S: fmt::Display>(
         sql_type: &str,
         checks: &[(T, S)],
     ) {
-        let conn = Connection::connect("postgres://postgres:password@localhost", TlsMode::None)
-            .unwrap();
+        let conn =
+            Connection::connect("postgres://postgres:password@localhost", TlsMode::None).unwrap();
         for &(ref val, ref repr) in checks.iter() {
-            let stmt = conn.prepare(&format!("SELECT {}::{}", *repr, sql_type))
+            let stmt = conn
+                .prepare(&format!("SELECT {}::{}", *repr, sql_type))
                 .unwrap();
             let result = stmt.query(&[]).unwrap().iter().next().unwrap().get(0);
             assert!(val == &result);
@@ -119,19 +113,24 @@ mod test {
     }
 
     macro_rules! test_array_params {
-        ($name:expr, $v1:expr, $s1:expr, $v2:expr, $s2:expr, $v3:expr, $s3:expr) => ({
-
-            let tests = &[(Some(Array::from_vec(vec!(Some($v1), Some($v2), None), 1)),
-                          format!("'{{{},{},NULL}}'", $s1, $s2)),
-                         (None, "NULL".to_string())];
+        ($name:expr, $v1:expr, $s1:expr, $v2:expr, $s2:expr, $v3:expr, $s3:expr) => {{
+            let tests = &[
+                (
+                    Some(Array::from_vec(vec![Some($v1), Some($v2), None], 1)),
+                    format!("'{{{},{},NULL}}'", $s1, $s2),
+                ),
+                (None, "NULL".to_string()),
+            ];
             test_type(&format!("{}[]", $name), tests);
-            let mut a = Array::from_vec(vec!(Some($v1), Some($v2)), 0);
+            let mut a = Array::from_vec(vec![Some($v1), Some($v2)], 0);
             a.wrap(-1);
-            a.push(Array::from_vec(vec!(None, Some($v3)), 0));
-            let tests = &[(Some(a), format!("'[-1:0][0:1]={{{{{},{}}},{{NULL,{}}}}}'",
-                                           $s1, $s2, $s3))];
+            a.push(Array::from_vec(vec![None, Some($v3)], 0));
+            let tests = &[(
+                Some(a),
+                format!("'[-1:0][0:1]={{{{{},{}}},{{NULL,{}}}}}'", $s1, $s2, $s3),
+            )];
             test_type(&format!("{}[][]", $name), tests);
-        })
+        }};
     }
 
     #[test]
diff --git a/src/lib.rs b/src/lib.rs
@@ -1,16 +1,8 @@
 //! Multi-dimensional arrays with per-dimension specifiable lower bounds
-#![doc(html_root_url="https://docs.rs/postgres_array/0.9.0")]
-
-extern crate fallible_iterator;
-#[macro_use]
-extern crate postgres_shared;
-extern crate postgres_protocol;
-
-#[cfg(test)]
-extern crate postgres;
+#![doc(html_root_url = "https://docs.rs/postgres_array/0.9.0")]
 
 #[doc(inline)]
-pub use array::Array;
+pub use crate::array::Array;
 
 pub mod array;
 mod impls;
@@ -47,13 +39,11 @@ mod tests {
     fn test_from_vec() {
         let a = Array::from_vec(vec![0i32, 1, 2], -1);
         assert!(
-            &[
-                Dimension {
-                    len: 3,
-                    lower_bound: -1,
-                },
-            ]
-                [..] == a.dimensions()
+            &[Dimension {
+                len: 3,
+                lower_bound: -1,
+            },][..]
+                == a.dimensions()
         );
         assert_eq!(0, a[-1]);
         assert_eq!(1, a[0]);
