[Cargo{.toml,.lock}] Upgrade all dependencies; add "cargo" feature to clap; [src/**.rs] rustfmt; conform to new dependency APIs; lint (#13)

Author: SamuelMarks

Cargo.lock

@@ -11,12 +11,12 @@ license = "MIT"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-rustyline = "7.1.0"
-log = "0.4.14"
-env_logger = "0.8.3"
-rustyline-derive = "0.4.0"
-clap = "2.33.3"
-sqlparser = "0.8.0"
-thiserror = "1.0.24"
-serde = { version = "1.0.123", features = ["derive", "rc"] }
-prettytable-rs = "^0.8"
+rustyline = "9.1.2"
+log = "0.4.17"
+env_logger = "0.9.0"
+rustyline-derive = "0.6.0"
+clap = { version = "3.1.18", features = ["cargo"] }
+sqlparser = "0.17.0"
+thiserror = "1.0.31"
+serde = { version = "1.0.137", features = ["derive", "rc"] }
+prettytable-rs = "0.8.0"

Cargo.toml

@@ -1,5 +1,6 @@
 extern crate clap;
-#[macro_use] extern crate prettytable;
+#[macro_use]
+extern crate prettytable;
 
 mod error;
 mod meta_command;
@@ -8,18 +9,18 @@ mod sql;
 
 use meta_command::handle_meta_command;
 use repl::{get_command_type, get_config, CommandType, REPLHelper};
-use sql::process_command;
 use sql::db::database::Database;
+use sql::process_command;
 
 use rustyline::error::ReadlineError;
 use rustyline::Editor;
 
-use clap::{crate_name ,crate_authors, crate_description, crate_version, App};
+use clap::{crate_authors, crate_description, crate_name, crate_version, Command};
 
 fn main() -> rustyline::Result<()> {
     env_logger::init();
 
-    let _matches = App::new(crate_name!())
+    let _matches = Command::new(crate_name!())
         .version(crate_version!())
         .author(crate_authors!())
         .about(crate_description!())

src/main.rs

@@ -1,8 +1,8 @@
 use crate::error::{Result, SQLRiteError};
 
-use std::fmt;
+use crate::repl::REPLHelper;
 use rustyline::Editor;
-use crate::repl::{REPLHelper};
+use std::fmt;
 
 #[derive(Debug, PartialEq)]
 pub enum MetaCommand {
@@ -42,7 +42,7 @@ pub fn handle_meta_command(command: MetaCommand, repl: &mut Editor<REPLHelper>)
         MetaCommand::Exit => {
             repl.append_history("history").unwrap();
             std::process::exit(0)
-        },
+        }
         MetaCommand::Help => Ok(format!(
             "{}{}{}{}{}{}{}{}",
             "Special commands:\n",

src/meta_command/mod.rs

@@ -1,7 +1,7 @@
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
 use crate::error::{Result, SQLRiteError};
 use crate::sql::db::table::Table;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 
 /// The database is represented by this structure.assert_eq!
 #[derive(Serialize, Deserialize, PartialEq, Debug)]
@@ -61,7 +61,7 @@ mod tests {
     use super::*;
     use crate::sql::parser::create::CreateQuery;
     use sqlparser::dialect::SQLiteDialect;
-    use sqlparser::parser::{Parser};
+    use sqlparser::parser::Parser;
 
     #[test]
     fn new_database_create_test() {
@@ -90,7 +90,8 @@ mod tests {
 
         let create_query = CreateQuery::new(&query).unwrap();
         let table_name = &create_query.table_name;
-        db.tables.insert(table_name.to_string(), Table::new(create_query));
+        db.tables
+            .insert(table_name.to_string(), Table::new(create_query));
 
         assert!(db.contains_table("contacts".to_string()));
     }
@@ -113,17 +114,17 @@ mod tests {
         }
         let query = ast.pop().unwrap();
 
-        let create_query = CreateQuery::new(&query).unwrap(); 
+        let create_query = CreateQuery::new(&query).unwrap();
         let table_name = &create_query.table_name;
-        db.tables.insert(table_name.to_string(), Table::new(create_query));
+        db.tables
+            .insert(table_name.to_string(), Table::new(create_query));
 
         let table = db.get_table(String::from("contacts")).unwrap();
         assert_eq!(table.columns.len(), 4);
 
         let mut table = db.get_table_mut(String::from("contacts")).unwrap();
         table.last_rowid += 1;
-        assert_eq!(table.columns.len(), 4); 
-        assert_eq!(table.last_rowid, 1); 
+        assert_eq!(table.columns.len(), 4);
+        assert_eq!(table.last_rowid, 1);
     }
-
-}
+}

src/sql/db/database.rs

@@ -1,2 +1,2 @@
 pub mod database;
-pub mod table;
+pub mod table;

src/sql/db/mod.rs

@@ -81,15 +81,13 @@ impl Table {
             if col.is_pk {
                 primary_key = col_name.to_string();
             }
-            table_cols.push(
-                Column::new(
-                    col_name.to_string(),
-                    col.datatype.to_string(),
-                    col.is_pk,
-                    col.not_null,
-                    col.is_unique,
-                ),
-            );
+            table_cols.push(Column::new(
+                col_name.to_string(),
+                col.datatype.to_string(),
+                col.is_pk,
+                col.not_null,
+                col.is_unique,
+            ));
 
             match DataType::new(col.datatype.to_string()) {
                 DataType::Integer => table_rows
@@ -139,27 +137,29 @@ impl Table {
     /// column with the specified key as a column name.
     ///
     pub fn get_column(&mut self, column_name: String) -> Result<&Column> {
-        if let Some(column) = self.columns
+        if let Some(column) = self
+            .columns
             .iter()
             .filter(|c| c.column_name == column_name)
             .collect::<Vec<&Column>>()
-            .first(){
-                Ok(column)
-            } else {
-                Err(SQLRiteError::General(String::from("Column not found.")))
-            }
+            .first()
+        {
+            Ok(column)
+        } else {
+            Err(SQLRiteError::General(String::from("Column not found.")))
+        }
     }
 
     /// Returns an mutable reference of `sql::db::table::Column` if the table contains a
     /// column with the specified key as a column name.
     ///
     pub fn get_column_mut<'a>(&mut self, column_name: String) -> Result<&mut Column> {
-            for elem in self.columns.iter_mut() {
-                if elem.column_name == column_name{
-                    return Ok(elem)
-                }
+        for elem in self.columns.iter_mut() {
+            if elem.column_name == column_name {
+                return Ok(elem);
             }
-            Err(SQLRiteError::General(String::from("Column not found.")))
+        }
+        Err(SQLRiteError::General(String::from("Column not found.")))
     }
 
     /// Validates if columns and values being inserted violate the UNIQUE constraint
@@ -224,7 +224,7 @@ impl Table {
         let mut next_rowid = self.last_rowid + i64::from(1);
 
         // Checks if table has a PRIMARY KEY
-        if self.primary_key != "-1"{
+        if self.primary_key != "-1" {
             // Checking if primary key is in INSERT QUERY columns
             // If it is not, assign the next_rowid to it
             if !cols.iter().any(|col| col == &self.primary_key) {
@@ -288,21 +288,21 @@ impl Table {
         // For every column in the INSERT statement
         for i in 0..column_names.len() {
             let mut val = String::from("Null");
-            let mut key = &column_names[i];
+            let key = &column_names[i];
 
-            if let Some(key) = &cols.get(j){
+            if let Some(key) = &cols.get(j) {
                 if &key.to_string() == &column_names[i] {
                     // Getting column name
                     val = values[j].to_string();
                     j += 1;
-                } else{
-                    if &self.primary_key == &column_names[i]{
-                        continue
+                } else {
+                    if &self.primary_key == &column_names[i] {
+                        continue;
                     }
                 }
-            }else{
-                if &self.primary_key == &column_names[i]{
-                    continue
+            } else {
+                if &self.primary_key == &column_names[i] {
+                    continue;
                 }
             }
 
@@ -367,10 +367,22 @@ impl Table {
     ///
     pub fn print_table_schema(&self) -> Result<usize> {
         let mut table = PrintTable::new();
-        table.add_row(row!["Column Name", "Data Type", "PRIMARY KEY", "UNIQUE", "NOT NULL"]);
+        table.add_row(row![
+            "Column Name",
+            "Data Type",
+            "PRIMARY KEY",
+            "UNIQUE",
+            "NOT NULL"
+        ]);
 
         for col in &self.columns {
-            table.add_row(row![col.column_name, col.datatype, col.is_pk, col.is_unique, col.not_null]);
+            table.add_row(row![
+                col.column_name,
+                col.datatype,
+                col.is_pk,
+                col.is_unique,
+                col.not_null
+            ]);
         }
 
         let lines = table.printstd();
@@ -415,7 +427,9 @@ impl Table {
 
         let rows_clone = Rc::clone(&self.rows);
         let row_data = rows_clone.as_ref().borrow();
-        let first_col_data = row_data.get(&self.columns.first().unwrap().column_name).unwrap();
+        let first_col_data = row_data
+            .get(&self.columns.first().unwrap().column_name)
+            .unwrap();
         let num_rows = first_col_data.count();
         let mut print_table_rows: Vec<PrintRow> = vec![PrintRow::new(vec![]); num_rows];
 
@@ -426,9 +440,9 @@ impl Table {
             let columns: Vec<String> = col_val.get_serialized_col_data();
 
             for i in 0..num_rows {
-                if let Some(cell) = &columns.get(i){
+                if let Some(cell) = &columns.get(i) {
                     print_table_rows[i].add_cell(PrintCell::new(cell));
-                }else{
+                } else {
                     print_table_rows[i].add_cell(PrintCell::new(""));
                 }
             }
@@ -524,10 +538,10 @@ pub enum Row {
 impl Row {
     fn get_serialized_col_data(&self) -> Vec<String> {
         match self {
-            Row::Integer(cd) => cd.iter().map(|(i, v)| v.to_string()).collect(),
-            Row::Real(cd) => cd.iter().map(|(i, v)| v.to_string()).collect(),
-            Row::Text(cd) => cd.iter().map(|(i, v)| v.to_string()).collect(),
-            Row::Bool(cd) => cd.iter().map(|(i, v)| v.to_string()).collect(),
+            Row::Integer(cd) => cd.iter().map(|(_i, v)| v.to_string()).collect(),
+            Row::Real(cd) => cd.iter().map(|(_i, v)| v.to_string()).collect(),
+            Row::Text(cd) => cd.iter().map(|(_i, v)| v.to_string()).collect(),
+            Row::Bool(cd) => cd.iter().map(|(_i, v)| v.to_string()).collect(),
             Row::None => panic!("Found None in columns"),
         }
     }
@@ -591,16 +605,18 @@ mod tests {
         assert_eq!(table.last_rowid, 0);
 
         let id_column = "id".to_string();
-        if let Some(column) = table.columns
+        if let Some(column) = table
+            .columns
             .iter()
             .filter(|c| c.column_name == id_column)
             .collect::<Vec<&Column>>()
-            .first() {
-                assert_eq!(column.is_pk, true);
-                assert_eq!(column.datatype, DataType::Integer);
-            } else {
-                panic!("column not found");
-            }
+            .first()
+        {
+            assert_eq!(column.is_pk, true);
+            assert_eq!(column.datatype, DataType::Integer);
+        } else {
+            panic!("column not found");
+        }
     }
 
     #[test]