Merge pull request diesel-rs#1687 from dreid/prefer-include-exclude

Use include/exclude instead of whitelist/blacklist.

Author: sgrif

CHANGELOG.md

@@ -54,6 +54,8 @@ for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/
   concerned about relying on deprecated code, we recommend attempting to build
   your app with `default-features` turned off (specifically excluding the
   `with-deprecated` feature).
+* The `--whitelist` and `--blacklist` options to `diesel print-schema` have been
+  deprecated and renamed `--only-tables` and `--exclude-tables`.
 
 ## [1.2.2] - 2018-04-12
 

diesel_cli/src/cli.rs

@@ -108,21 +108,39 @@ pub fn build_cli() -> App<'static, 'static> {
                 .index(1)
                 .takes_value(true)
                 .multiple(true)
-                .help("Table names to filter (default whitelist if not empty)"),
+                .help("Table names to filter (default only-tables if not empty)"),
+        )
+        .arg(
+            Arg::with_name("only-tables")
+                .short("o")
+                .long("only-tables")
+                .help("Only include tables from table-name")
+                .conflicts_with("except-tables")
+                .conflicts_with("blacklist"),
         )
         .arg(
             Arg::with_name("whitelist")
                 .short("w")
                 .long("whitelist")
-                .help("Use table list as whitelist")
-                .conflicts_with("blacklist"),
+                .hidden(true)
+                .conflicts_with("blacklist")
+                .conflicts_with("except-tables"),
+        )
+        .arg(
+            Arg::with_name("except-tables")
+                .short("e")
+                .long("except-tables")
+                .help("Exclude tables from table-name")
+                .conflicts_with("only-tables")
+                .conflicts_with("whitelist"),
         )
         .arg(
             Arg::with_name("blacklist")
                 .short("b")
                 .long("blacklist")
-                .help("Use table list as blacklist")
-                .conflicts_with("whitelist"),
+                .hidden(true)
+                .conflicts_with("whitelist")
+                .conflicts_with("only-tables"),
         )
         .arg(
             Arg::with_name("with-docs")

diesel_cli/src/main.rs

@@ -353,9 +353,17 @@ fn run_infer_schema(matches: &ArgMatches) -> Result<(), Box<Error>> {
         .collect();
 
     if matches.is_present("whitelist") {
-        config.filter = Filtering::Whitelist(filter)
-    } else if matches.is_present("blacklist") {
-        config.filter = Filtering::Blacklist(filter)
+        eprintln!("The `whitelist` option has been deprecated and renamed to `only-tables`.");
+    }
+
+    if matches.is_present("blacklist") {
+        eprintln!("The `whitelist` option has been deprecated and renamed to `except-tables`.");
+    }
+
+    if matches.is_present("only-tables") || matches.is_present("whitelist") {
+        config.filter = Filtering::OnlyTables(filter)
+    } else if matches.is_present("except-tables") || matches.is_present("blacklist") {
+        config.filter = Filtering::ExceptTables(filter)
     }
 
     if matches.is_present("with-docs") {

diesel_cli/src/print_schema.rs

@@ -12,8 +12,8 @@ use std::process::Command;
 use tempfile::NamedTempFile;
 
 pub enum Filtering {
-    Whitelist(Vec<TableName>),
-    Blacklist(Vec<TableName>),
+    OnlyTables(Vec<TableName>),
+    ExceptTables(Vec<TableName>),
     None,
 }
 
@@ -28,8 +28,8 @@ impl Filtering {
         use self::Filtering::*;
 
         match *self {
-            Whitelist(ref names) => !names.contains(name),
-            Blacklist(ref names) => names.contains(name),
+            OnlyTables(ref names) => !names.contains(name),
+            ExceptTables(ref names) => names.contains(name),
             None => false,
         }
     }
@@ -306,36 +306,41 @@ impl<'de> Deserialize<'de> for Filtering {
             type Value = Filtering;
 
             fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                f.write_str("either a whitelist or a blacklist")
+                f.write_str("either only-tables or except-tables")
             }
 
             fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
             where
                 V: MapAccess<'de>,
             {
-                let mut whitelist = None;
-                let mut blacklist = None;
+                let mut only_tables = None;
+                let mut except_tables = None;
                 while let Some((key, value)) = map.next_entry()? {
                     match key {
-                        "whitelist" => {
-                            if whitelist.is_some() {
-                                return Err(de::Error::duplicate_field("whitelist"));
+                        "only-tables" => {
+                            if only_tables.is_some() {
+                                return Err(de::Error::duplicate_field("only-tables"));
                             }
-                            whitelist = Some(value);
+                            only_tables = Some(value);
                         }
-                        "blacklist" => {
-                            if blacklist.is_some() {
-                                return Err(de::Error::duplicate_field("blacklist"));
+                        "except-tables" => {
+                            if except_tables.is_some() {
+                                return Err(de::Error::duplicate_field("except-tables"));
                             }
-                            blacklist = Some(value);
+                            except_tables = Some(value);
+                        }
+                        _ => {
+                            return Err(de::Error::unknown_field(
+                                key,
+                                &["only-tables", "except-tables"],
+                            ))
                         }
-                        _ => return Err(de::Error::unknown_field(key, &["whitelist", "blacklist"])),
                     }
                 }
-                match (whitelist, blacklist) {
-                    (Some(_), Some(_)) => Err(de::Error::duplicate_field("blacklist")),
-                    (Some(w), None) => Ok(Filtering::Whitelist(w)),
-                    (None, Some(b)) => Ok(Filtering::Blacklist(b)),
+                match (only_tables, except_tables) {
+                    (Some(_), Some(_)) => Err(de::Error::duplicate_field("except-tables")),
+                    (Some(w), None) => Ok(Filtering::OnlyTables(w)),
+                    (None, Some(b)) => Ok(Filtering::ExceptTables(b)),
                     (None, None) => Ok(Filtering::None),
                 }
             }

diesel_cli/tests/print_schema.rs

@@ -15,17 +15,17 @@ fn run_infer_schema() {
 }
 
 #[test]
-fn run_infer_schema_whitelist() {
+fn run_infer_schema_include() {
     test_print_schema(
-        "print_schema_whitelist",
+        "print_schema_only_tables",
         vec!["--with-docs", "-w", "users1"],
     );
 }
 
 #[test]
-fn run_infer_schema_blacklist() {
+fn run_infer_schema_exclude() {
     test_print_schema(
-        "print_schema_blacklist",
+        "print_schema_except_tables",
         vec!["--with-docs", "-b", "users1"],
     );
 }

…chema/print_schema_whitelist/diesel.toml …a/print_schema_except_tables/diesel.tomldiesel_cli/tests/print_schema/print_schema_whitelist/diesel.toml renamed to diesel_cli/tests/print_schema/print_schema_except_tables/diesel.toml diesel_cli/tests/print_schema/print_schema_whitelist/diesel.toml renamed to diesel_cli/tests/print_schema/print_schema_except_tables/diesel.toml

@@ -1,4 +1,4 @@
 [print_schema]
 file = "src/schema.rs"
 with_docs = true
-filter = { whitelist = ["users1"] }
+filter = { except-tables = ["users1"] }