Rewrite embed_migrations! to be a real proc macro

Remove the proc-macro-hack for `embed_migrations!` as it is not
required anymore. This enables importing the macro via use.
Also migrates `migrations_macros` to the 2018 edition.

Author: weiznich

.travis.yml

@@ -71,7 +71,7 @@ script:
   (cd "examples/$BACKEND" && ./test_all) &&
   (cd diesel_cli && cargo test --no-default-features --features "$BACKEND") &&
   (cd diesel_migrations/migrations_internals && cargo test ) &&
-  (cd diesel_migrations/migrations_macros && cargo test ) &&
+  (cd diesel_migrations/migrations_macros && cargo test --features "$BACKEND diesel/$BACKEND" ) &&
   (cd diesel_migrations/ && cargo test  --features "$BACKEND diesel/$BACKEND" ) &&
   if [[ "$TRAVIS_RUST_VERSION" == nightly* ]]; then
     (cd diesel_tests && cargo test --no-default-features --features "unstable $BACKEND")

_build/azure-pipelines-template.yml

@@ -60,7 +60,7 @@ jobs:
       rust_version: $(RUSTUP_TOOLCHAIN)
       bash: |
         (cd diesel_migrations/migrations_internals && cargo test  ) &&
-        (cd diesel_migrations/migrations_macros && cargo test ) &&
+        (cd diesel_migrations/migrations_macros && cargo test --features "$BACKEND diesel/$BACKEND" ) &&
         (cd diesel_migrations/ && cargo test --features "$BACKEND diesel/$BACKEND" )
       displayName: Test diesel-migrations
   - template: failable_step.yml

diesel_migrations/migrations_macros/Cargo.toml

@@ -6,9 +6,9 @@ license = "MIT OR Apache-2.0"
 description = "Codegeneration macros for diesels embedded migrations"
 documentation = "https://docs.diesel.rs"
 homepage = "https://diesel.rs"
+edition = "2018"
 
 [dependencies]
-syn = { version = "1", features = ["extra-traits"] }
 quote = "1"
 proc-macro2 = "1"
 
@@ -18,9 +18,24 @@ path = "../migrations_internals"
 
 [dev-dependencies]
 tempfile = "3.0.0"
+dotenv = ">=0.8, <0.11"
+cfg-if = "0.1.0"
+
+[dev-dependencies.diesel]
+version = "~2.0.0"
+path = "../../diesel"
+default-features = false
+
+[dev-dependencies.diesel_migrations]
+version = "~1.4.0"
+path = "../"
+default-features = false
 
 [lib]
 proc-macro = true
 
 [features]
 default = []
+sqlite = []
+postgresql = []
+mysql = []

diesel_migrations/migrations_macros/src/embed_migrations.rs

@@ -1,27 +1,17 @@
-use proc_macro2;
-use syn;
-
-use migrations::migration_directory_from_given_path;
+use crate::migrations::migration_directory_from_given_path;
 use migrations_internals::{migration_paths_in_directory, version_from_path};
+use quote::quote;
 use std::error::Error;
 use std::fs::DirEntry;
 use std::path::Path;
 
-use util::{get_option, get_options_from_input};
-
-pub fn derive_embed_migrations(input: &syn::DeriveInput) -> proc_macro2::TokenStream {
-    fn bug() -> ! {
-        panic!(
-            "This is a bug. Please open a Github issue \
-             with your invocation of `embed_migrations!"
-        );
-    }
-
-    let options =
-        get_options_from_input(&parse_quote!(embed_migrations_options), &input.attrs, bug);
-    let migrations_path_opt = options
-        .as_ref()
-        .map(|o| get_option(o, "migrations_path", bug));
+pub fn expand(path: String) -> proc_macro2::TokenStream {
+    dbg!(&path);
+    let migrations_path_opt = if path.is_empty() {
+        None
+    } else {
+        Some(path.replace("\"", ""))
+    };
     let migrations_expr =
         migration_directory_from_given_path(migrations_path_opt.as_ref().map(String::as_str))
             .and_then(|path| migration_literals_from_path(&path));
@@ -30,54 +20,48 @@ pub fn derive_embed_migrations(input: &syn::DeriveInput) -> proc_macro2::TokenSt
         Err(e) => panic!("Error reading migrations: {}", e),
     };
 
-    // These are split into multiple `quote!` calls to avoid recursion limit
-    let embedded_migration_def = quote!(
-        struct EmbeddedMigration {
-            version: &'static str,
-            up_sql: &'static str,
-        }
+    quote! {
+        #[allow(dead_code)]
+        mod embedded_migrations {
+            extern crate diesel;
+            extern crate diesel_migrations;
 
-        impl Migration for EmbeddedMigration {
-            fn version(&self) -> &str {
-                self.version
-            }
+            use self::diesel_migrations::*;
+            use self::diesel::connection::SimpleConnection;
+            use std::io;
 
-            fn run(&self, conn: &SimpleConnection) -> Result<(), RunMigrationsError> {
-                conn.batch_execute(self.up_sql).map_err(Into::into)
-            }
+            const ALL_MIGRATIONS: &[&Migration] = &[#(#migrations_expr),*];
 
-            fn revert(&self, _conn: &SimpleConnection) -> Result<(), RunMigrationsError> {
-                unreachable!()
+            struct EmbeddedMigration {
+                version: &'static str,
+                up_sql: &'static str,
             }
-        }
-    );
 
-    let run_fns = quote!(
-        pub fn run<C: MigrationConnection>(conn: &C) -> Result<(), RunMigrationsError> {
-            run_with_output(conn, &mut io::sink())
-        }
-
-        pub fn run_with_output<C: MigrationConnection>(
-            conn: &C,
-            out: &mut io::Write,
-        ) -> Result<(), RunMigrationsError> {
-            run_migrations(conn, ALL_MIGRATIONS.iter().map(|v| *v), out)
-        }
-    );
-
-    quote! {
-        extern crate diesel;
-        extern crate diesel_migrations;
+            impl Migration for EmbeddedMigration {
+                fn version(&self) -> &str {
+                    self.version
+                }
 
-        use self::diesel_migrations::*;
-        use self::diesel::connection::SimpleConnection;
-        use std::io;
+                fn run(&self, conn: &SimpleConnection) -> Result<(), RunMigrationsError> {
+                    conn.batch_execute(self.up_sql).map_err(Into::into)
+                }
 
-        const ALL_MIGRATIONS: &[&Migration] = &[#(#migrations_expr),*];
+                fn revert(&self, _conn: &SimpleConnection) -> Result<(), RunMigrationsError> {
+                    unreachable!()
+                }
+            }
 
-        #embedded_migration_def
+            pub fn run<C: MigrationConnection>(conn: &C) -> Result<(), RunMigrationsError> {
+                run_with_output(conn, &mut io::sink())
+            }
 
-        #run_fns
+            pub fn run_with_output<C: MigrationConnection>(
+                conn: &C,
+                out: &mut io::Write,
+            ) -> Result<(), RunMigrationsError> {
+                run_migrations(conn, ALL_MIGRATIONS.iter().map(|v| *v), out)
+            }
+        }
     }
 }
 

diesel_migrations/migrations_macros/src/lib.rs

@@ -21,25 +21,57 @@
     clippy::used_underscore_binding
 )]
 #![cfg_attr(test, allow(clippy::option_unwrap_used, clippy::result_unwrap_used))]
-extern crate migrations_internals;
 extern crate proc_macro;
-extern crate proc_macro2;
-#[macro_use]
-extern crate quote;
-#[macro_use]
-extern crate syn;
 
 mod embed_migrations;
 mod migrations;
-mod util;
 
 use proc_macro::TokenStream;
-use syn::DeriveInput;
 
-#[proc_macro_derive(EmbedMigrations, attributes(embed_migrations_options))]
-pub fn derive_embed_migrations(input: TokenStream) -> TokenStream {
-    let item = parse_macro_input!(input as DeriveInput);
-    embed_migrations::derive_embed_migrations(&item)
+/// This macro will read your migrations at compile time, and embed a module you can use to execute
+/// them at runtime without the migration files being present on the file system. This is useful if
+/// you would like to use Diesel's migration infrastructure, but want to ship a single executable
+/// file (such as for embedded applications). It can also be used to apply migrations to an in
+/// memory database (Diesel does this for its own test suite).
+///
+/// You can optionally pass the path to the migrations directory to this macro. When left
+/// unspecified, Diesel Codegen will search for the migrations directory in the same way that
+/// Diesel CLI does. If specified, the path should be relative to the directory where `Cargo.toml`
+/// resides.
+///
+/// # Examples
+///
+/// ```rust
+/// # use diesel_migrations::embed_migrations;
+/// # include!("../../../diesel/src/doctest_setup.rs");
+/// # table! {
+/// #   users {
+/// #       id -> Integer,
+/// #       name -> VarChar,
+/// #   }
+/// # }
+/// #
+/// # #[cfg(feature = "postgres")]
+/// # embed_migrations!("../../migrations/postgresql");
+/// # #[cfg(all(feature = "mysql", not(feature = "postgres")))]
+/// # embed_migrations!("../../migrations/mysql");
+/// # #[cfg(all(feature = "sqlite", not(any(feature = "postgres", feature = "mysql"))))]
+/// embed_migrations!("../../migrations/sqlite");
+///
+/// fn main() {
+///     let connection = establish_connection();
+///
+///     // This will run the necessary migrations.
+///     embedded_migrations::run(&connection);
+///
+///     // By default the output is thrown out. If you want to redirect it to stdout, you
+///     // should call embedded_migrations::run_with_output.
+///     embedded_migrations::run_with_output(&connection, &mut std::io::stdout());
+/// }
+/// ```
+#[proc_macro]
+pub fn embed_migrations(input: TokenStream) -> TokenStream {
+    embed_migrations::expand(input.to_string())
         .to_string()
         .parse()
         .unwrap()

diesel_migrations/migrations_macros/src/migrations.rs

@@ -32,7 +32,7 @@ fn resolve_migrations_directory(
 
 #[cfg(test)]
 mod tests {
-    extern crate tempfile;
+    use tempfile;
 
     use self::tempfile::Builder;
     use super::resolve_migrations_directory;

diesel_migrations/src/lib.rs

@@ -130,64 +130,5 @@ pub mod connection {
     pub use migrations_internals::connection::MigrationConnection;
 }
 
-#[macro_export]
-/// This macro will read your migrations at compile time, and embed a module you can use to execute
-/// them at runtime without the migration files being present on the file system. This is useful if
-/// you would like to use Diesel's migration infrastructure, but want to ship a single executable
-/// file (such as for embedded applications). It can also be used to apply migrations to an in
-/// memory database (Diesel does this for its own test suite).
-///
-/// You can optionally pass the path to the migrations directory to this macro. When left
-/// unspecified, Diesel Codegen will search for the migrations directory in the same way that
-/// Diesel CLI does. If specified, the path should be relative to the directory where `Cargo.toml`
-/// resides.
-///
-/// # Examples
-///
-/// ```rust
-/// # #[macro_use] extern crate diesel;
-/// # #[macro_use] extern crate diesel_migrations;
-/// # include!("../../diesel/src/doctest_setup.rs");
-/// # table! {
-/// #   users {
-/// #       id -> Integer,
-/// #       name -> VarChar,
-/// #   }
-/// # }
-/// #
-/// # #[cfg(feature = "postgres")]
-/// # embed_migrations!("../migrations/postgresql");
-/// # #[cfg(all(feature = "mysql", not(feature = "postgres")))]
-/// # embed_migrations!("../migrations/mysql");
-/// # #[cfg(all(feature = "sqlite", not(any(feature = "postgres", feature = "mysql"))))]
-/// embed_migrations!("../migrations/sqlite");
-///
-/// fn main() {
-///     let connection = establish_connection();
-///
-///     // This will run the necessary migrations.
-///     embedded_migrations::run(&connection);
-///
-///     // By default the output is thrown out. If you want to redirect it to stdout, you
-///     // should call embedded_migrations::run_with_output.
-///     embedded_migrations::run_with_output(&connection, &mut std::io::stdout());
-/// }
-/// ```
-macro_rules! embed_migrations {
-    () => {
-        #[allow(dead_code)]
-        mod embedded_migrations {
-            #[derive(EmbedMigrations)]
-            struct _Dummy;
-        }
-    };
-
-    ($migrations_path:expr) => {
-        #[allow(dead_code)]
-        mod embedded_migrations {
-            #[derive(EmbedMigrations)]
-            #[embed_migrations_options(migrations_path=$migrations_path)]
-            struct _Dummy;
-        }
-    };
-}
+#[doc(inline)]
+pub use migrations_macros::embed_migrations;