Cargo fix + cargo clippy for wundergraph_cli

Author: weiznich

wundergraph_cli/Cargo.toml

@@ -8,6 +8,7 @@ readme = "../README.md"
 keywords = ["GraphQL", "ORM", "PostgreSQL", "SQLite"]
 categories = ["database", "web-programming"]
 description = "A helper tool to generate some code for using wundergraph with existing databases"
+edition = "2018"
 
 [dependencies]
 structopt = "0.2"

wundergraph_cli/src/database.rs

@@ -67,7 +67,7 @@ pub enum InferConnection {
 }
 
 impl InferConnection {
-    pub fn establish(database_url: &str) -> Result<Self, Box<Error>> {
+    pub fn establish(database_url: &str) -> Result<Self, Box<dyn Error>> {
         match Backend::for_url(database_url) {
             #[cfg(feature = "postgres")]
             Backend::Pg => PgConnection::establish(database_url).map(InferConnection::Pg),

wundergraph_cli/src/infer_schema_internals/data_structures.rs

@@ -28,7 +28,7 @@ pub struct ColumnType {
 use std::fmt;
 
 impl fmt::Display for ColumnType {
-    fn fmt(&self, out: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, out: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         if self.is_nullable {
             write!(out, "Nullable<")?;
         }

wundergraph_cli/src/infer_schema_internals/foreign_keys.rs

@@ -1,41 +1,39 @@
-#![cfg_attr(feature = "cargo-clippy", allow(expect_fun_call))] // My calls are so fun
-
 use super::data_structures::ForeignKeyConstraint;
 use super::inference::get_primary_keys;
 use super::table_data::TableName;
-use database::InferConnection;
+use crate::database::InferConnection;
 
 pub fn remove_unsafe_foreign_keys_for_codegen(
     database_url: &str,
     foreign_keys: &[ForeignKeyConstraint],
     safe_tables: &[TableName],
 ) -> Vec<ForeignKeyConstraint> {
     let conn = InferConnection::establish(database_url)
-        .expect(&format!("Could not connect to `{}`", database_url));
+        .unwrap_or_else(|_| panic!("Could not connect to `{}`", database_url));
 
     let duplicates = foreign_keys
         .iter()
-        .map(|fk| fk.ordered_tables())
+        .map(ForeignKeyConstraint::ordered_tables)
         .filter(|tables| {
             let dup_count = foreign_keys
                 .iter()
                 .filter(|fk| tables == &fk.ordered_tables())
                 .count();
             dup_count > 1
-        }).collect::<Vec<_>>();
+        })
+        .collect::<Vec<_>>();
 
     foreign_keys
         .iter()
         .filter(|fk| fk.parent_table != fk.child_table)
         .filter(|fk| safe_tables.contains(&fk.parent_table))
         .filter(|fk| safe_tables.contains(&fk.child_table))
         .filter(|fk| {
-            let pk_columns = get_primary_keys(&conn, &fk.parent_table).expect(&format!(
-                "Error loading primary keys for `{}`",
-                fk.parent_table
-            ));
+            let pk_columns = get_primary_keys(&conn, &fk.parent_table)
+                .unwrap_or_else(|_| panic!("Error loading primary keys for `{}`", fk.parent_table));
             pk_columns.len() == 1 && pk_columns[0] == fk.primary_key
-        }).filter(|fk| !duplicates.contains(&fk.ordered_tables()))
+        })
+        .filter(|fk| !duplicates.contains(&fk.ordered_tables()))
         .cloned()
         .collect()
 }

wundergraph_cli/src/infer_schema_internals/inference.rs

@@ -4,7 +4,7 @@ use diesel::result::Error::NotFound;
 
 use super::data_structures::*;
 use super::table_data::*;
-use database::InferConnection;
+use crate::database::InferConnection;
 
 static RESERVED_NAMES: &[&str] = &[
     "abstract", "alignof", "as", "become", "box", "break", "const", "continue", "crate", "do",
@@ -17,8 +17,8 @@ static RESERVED_NAMES: &[&str] = &[
 pub fn load_table_names(
     database_url: &str,
     schema_name: Option<&str>,
-) -> Result<Vec<TableName>, Box<Error>> {
-    let connection = try!(InferConnection::establish(database_url));
+) -> Result<Vec<TableName>, Box<dyn Error>> {
+    let connection = r#try!(InferConnection::establish(database_url));
 
     match connection {
         #[cfg(feature = "sqlite")]
@@ -33,7 +33,7 @@ pub fn load_table_names(
 fn get_column_information(
     conn: &InferConnection,
     table: &TableName,
-) -> Result<Vec<ColumnInformation>, Box<Error>> {
+) -> Result<Vec<ColumnInformation>, Box<dyn Error>> {
     let column_info = match *conn {
         #[cfg(feature = "sqlite")]
         InferConnection::Sqlite(ref c) => super::sqlite::get_table_data(c, table),
@@ -52,7 +52,7 @@ fn get_column_information(
 fn determine_column_type(
     attr: &ColumnInformation,
     conn: &InferConnection,
-) -> Result<ColumnType, Box<Error>> {
+) -> Result<ColumnType, Box<dyn Error>> {
     match *conn {
         #[cfg(feature = "sqlite")]
         InferConnection::Sqlite(_) => super::sqlite::determine_column_type(attr),
@@ -66,8 +66,8 @@ fn determine_column_type(
 pub(crate) fn get_primary_keys(
     conn: &InferConnection,
     table: &TableName,
-) -> Result<Vec<String>, Box<Error>> {
-    let primary_keys: Vec<String> = try!(match *conn {
+) -> Result<Vec<String>, Box<dyn Error>> {
+    let primary_keys: Vec<String> = r#try!(match *conn {
         #[cfg(feature = "sqlite")]
         InferConnection::Sqlite(ref c) => super::sqlite::get_primary_keys(c, table),
         #[cfg(feature = "postgres")]
@@ -89,8 +89,8 @@ pub(crate) fn get_primary_keys(
 pub fn load_foreign_key_constraints(
     database_url: &str,
     schema_name: Option<&str>,
-) -> Result<Vec<ForeignKeyConstraint>, Box<Error>> {
-    let connection = try!(InferConnection::establish(database_url));
+) -> Result<Vec<ForeignKeyConstraint>, Box<dyn Error>> {
+    let connection = r#try!(InferConnection::establish(database_url));
 
     let constraints = match connection {
         #[cfg(feature = "sqlite")]
@@ -122,7 +122,7 @@ macro_rules! doc_comment {
     };
 }
 
-pub fn load_table_data(database_url: &str, name: TableName) -> Result<TableData, Box<Error>> {
+pub fn load_table_data(database_url: &str, name: TableName) -> Result<TableData, Box<dyn Error>> {
     let connection = InferConnection::establish(database_url)?;
     let docs = doc_comment!(
         "Representation of the `{}` table.
@@ -167,7 +167,7 @@ pub fn load_table_data(database_url: &str, name: TableName) -> Result<TableData,
                 rust_name,
                 has_default: c.has_default,
             })
-        }).collect::<Result<_, Box<Error>>>()?;
+        }).collect::<Result<_, Box<dyn Error>>>()?;
 
     Ok(TableData {
         name,