Adding barrel feature

diesel/src/lib.rs

@@ -159,6 +159,7 @@ pub mod serialize;
 pub mod sql_types;
 pub mod types;
 pub mod row;
+pub mod migration;
 
 #[cfg(feature = "mysql")]
 pub mod mysql;

diesel_migrations/migrations_internals/src/migration_error.rs → diesel/src/migration/errors.rs

@@ -1,16 +1,27 @@
-use diesel::result;
+//! Error types that represent migration errors.
+//! 
+//! These are split into multiple segments, depending on
+//! where in the migration process an error occurs.
 
 use std::convert::From;
 use std::{fmt, io};
 use std::path::PathBuf;
 use std::error::Error;
 
+use result;
+
+/// Errors that occur while preparing to run migrations
 #[derive(Debug)]
 pub enum MigrationError {
+    /// The migration directory wasn't found
     MigrationDirectoryNotFound,
+    /// Provided migration was in an unknown format
     UnknownMigrationFormat(PathBuf),
+    /// General system IO error
     IoError(io::Error),
+    /// Provided migration had an incompatible version number
     UnknownMigrationVersion(String),
+    /// No migrations had to be/ could be run
     NoMigrationRun,
 }
 
@@ -63,11 +74,15 @@ impl From<io::Error> for MigrationError {
     }
 }
 
+/// Errors that occur while running migrations
 #[derive(Debug, PartialEq)]
 #[cfg_attr(feature = "clippy", allow(enum_variant_names))]
 pub enum RunMigrationsError {
+    /// A general migration error occured
     MigrationError(MigrationError),
+    /// The provided migration included an invalid query
     QueryError(result::Error),
+    /// The provided migration was empty
     EmptyMigration,
 }
 

diesel/src/migration/mod.rs

@@ -0,0 +1,86 @@
+//!
+
+pub mod errors;
+pub use self::errors::*;
+
+use connection::SimpleConnection;
+use std::path::Path;
+use std::fmt;
+
+/// Represents a migration that interacts with diesel
+pub trait Migration {
+    /// Get the migration version
+    fn version(&self) -> &str;
+    /// Apply this migration
+    fn run(&self, conn: &SimpleConnection) -> Result<(), RunMigrationsError>;
+    /// Revert this migration
+    fn revert(&self, conn: &SimpleConnection) -> Result<(), RunMigrationsError>;
+    /// Get the migration file path
+    fn file_path(&self) -> Option<&Path> {
+        None
+    }
+}
+
+/// A migration name
+#[allow(missing_debug_implementations)]
+#[derive(Clone, Copy)]
+pub struct MigrationName<'a> {
+    /// Wraps around a migration
+    pub migration: &'a Migration,
+}
+
+/// Get the name of a migration
+pub fn name(migration: &Migration) -> MigrationName {
+    MigrationName {
+        migration: migration,
+    }
+}
+
+impl<'a> fmt::Display for MigrationName<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let file_name = self.migration
+            .file_path()
+            .and_then(|file_path| file_path.file_name())
+            .and_then(|file| file.to_str());
+        if let Some(name) = file_name {
+            f.write_str(name)?;
+        } else {
+            f.write_str(self.migration.version())?;
+        }
+        Ok(())
+    }
+}
+
+impl Migration for Box<Migration> {
+    fn version(&self) -> &str {
+        (&**self).version()
+    }
+
+    fn run(&self, conn: &SimpleConnection) -> Result<(), RunMigrationsError> {
+        (&**self).run(conn)
+    }
+
+    fn revert(&self, conn: &SimpleConnection) -> Result<(), RunMigrationsError> {
+        (&**self).revert(conn)
+    }
+    fn file_path(&self) -> Option<&Path> {
+        (&**self).file_path()
+    }
+}
+
+impl<'a> Migration for &'a Migration {
+    fn version(&self) -> &str {
+        (&**self).version()
+    }
+
+    fn run(&self, conn: &SimpleConnection) -> Result<(), RunMigrationsError> {
+        (&**self).run(conn)
+    }
+
+    fn revert(&self, conn: &SimpleConnection) -> Result<(), RunMigrationsError> {
+        (&**self).revert(conn)
+    }
+    fn file_path(&self) -> Option<&Path> {
+        (&**self).file_path()
+    }
+}

diesel_cli/Cargo.toml

@@ -23,6 +23,7 @@ infer_schema_internals = { version = "1.1.0" }
 clippy = { optional = true, version = "=0.0.185" }
 migrations_internals = { version = "1.1.0" }
 url = { version = "1.4.0", optional = true }
+barrel = { git = "https://github.com/spacekookie/barrel", optional = true, features = ["diesel"] }
 
 [dev-dependencies]
 difference = "1.0"
@@ -36,6 +37,7 @@ lint = ["clippy"]
 postgres = ["diesel/postgres", "infer_schema_internals/postgres", "url"]
 sqlite = ["diesel/sqlite", "infer_schema_internals/sqlite"]
 mysql = ["diesel/mysql", "infer_schema_internals/mysql", "url"]
+barrels = ["migrations_internals/barrel", "barrel"]
 
 [[test]]
 name = "tests"

diesel_cli/src/cli.rs

@@ -51,6 +51,15 @@ pub fn build_cli() -> App<'static, 'static> {
                              for most use cases.",
                         )
                         .takes_value(true),
+                )
+                .arg(
+                    Arg::with_name("TYPE")
+                        .long("type")
+                        .short("t")
+                        .possible_values(&["sql", "barrel"])
+                        .default_value("sql")
+                        .takes_value(true)
+                        .help("Specify the migration type."),
                 ),
         )
         .setting(AppSettings::SubcommandRequiredElseHelp);

diesel_cli/src/main.rs

@@ -20,6 +20,9 @@ extern crate migrations_internals;
 #[cfg(feature = "url")]
 extern crate url;
 
+#[cfg(feature = "barrel")]
+extern crate barrel;
+
 mod database_error;
 #[macro_use]
 mod database;
@@ -105,38 +108,47 @@ fn run_migration_command(matches: &ArgMatches) {
             println!("{:?}", result.unwrap());
         }
         ("generate", Some(args)) => {
-            use std::io::Write;
-
             let migration_name = args.value_of("MIGRATION_NAME").unwrap();
             let version = migration_version(args);
             let versioned_name = format!("{}_{}", version, migration_name);
             let migration_dir = migrations_dir(matches).join(versioned_name);
+            let migration_type: Option<&str> = args.value_of("TYPE");
             fs::create_dir(&migration_dir).unwrap();
 
-            let migration_dir_relative =
-                convert_absolute_path_to_relative(&migration_dir, &env::current_dir().unwrap());
-
-            let up_path = migration_dir.join("up.sql");
-            println!(
-                "Creating {}",
-                migration_dir_relative.join("up.sql").display()
-            );
-            let mut up = fs::File::create(up_path).unwrap();
-            up.write_all(b"-- Your SQL goes here").unwrap();
-
-            let down_path = migration_dir.join("down.sql");
-            println!(
-                "Creating {}",
-                migration_dir_relative.join("down.sql").display()
-            );
-            let mut down = fs::File::create(down_path).unwrap();
-            down.write_all(b"-- This file should undo anything in `up.sql`")
-                .unwrap();
+            match migration_type {
+                #[cfg(feature = "barrel")]
+                Some("barrel") => barrel::diesel::generate_initial(migration_dir),
+                _ => generate_sql_migration(migration_dir),
+            }
         }
         _ => unreachable!("The cli parser should prevent reaching here"),
     }
 }
 
+fn generate_sql_migration(path: PathBuf) {
+    use std::io::Write;
+
+    let migration_dir_relative =
+        convert_absolute_path_to_relative(&path, &env::current_dir().unwrap());
+
+    let up_path = path.join("up.sql");
+    println!(
+        "Creating {}",
+        migration_dir_relative.join("up.sql").display()
+    );
+    let mut up = fs::File::create(up_path).unwrap();
+    up.write_all(b"-- Your SQL goes here").unwrap();
+
+    let down_path = path.join("down.sql");
+    println!(
+        "Creating {}",
+        migration_dir_relative.join("down.sql").display()
+    );
+    let mut down = fs::File::create(down_path).unwrap();
+    down.write_all(b"-- This file should undo anything in `up.sql`")
+        .unwrap();
+}
+
 use std::fmt::Display;
 fn migration_version<'a>(matches: &'a ArgMatches) -> Box<Display + 'a> {
     matches

diesel_migrations/migrations_internals/Cargo.toml

@@ -9,6 +9,7 @@ homepage = "http://diesel.rs"
 [dependencies]
 clippy = { optional = true, version = "=0.0.185" }
 diesel = { version = "1.1.0", default-features = false }
+barrel = { git = "https://github.com/spacekookie/barrel", optional = true, features = ["diesel_filled"] }
 
 [dev-dependencies]
 tempdir = "0.3.4"

diesel_migrations/migrations_internals/src/lib.rs

@@ -77,22 +77,25 @@
 #[macro_use]
 extern crate diesel;
 
-mod migration;
+#[cfg(feature = "barrel")]
+extern crate barrel;
+
+pub mod migration;
 #[doc(hidden)]
 pub mod connection;
-mod migration_error;
 #[doc(hidden)]
 pub mod schema;
 
 #[doc(inline)]
 pub use self::connection::MigrationConnection;
 #[doc(inline)]
 pub use self::migration::*;
-pub use self::migration_error::*;
+// pub use self::migration_error::*;
 
 use std::fs::DirEntry;
 use std::io::{stdout, Write};
 
+use diesel::migration::*;
 use diesel::expression_methods::*;
 use diesel::{Connection, QueryDsl, QueryResult, RunQueryDsl};
 use self::schema::__diesel_schema_migrations::dsl::*;

diesel_migrations/migrations_internals/src/migration.rs

@@ -1,46 +1,15 @@
 use diesel::connection::SimpleConnection;
-use super::{MigrationError, RunMigrationsError};
+use diesel::migration::*;
 
 use std::path::{Path, PathBuf};
-use std::fmt;
 
-pub trait Migration {
-    fn version(&self) -> &str;
-    fn run(&self, conn: &SimpleConnection) -> Result<(), RunMigrationsError>;
-    fn revert(&self, conn: &SimpleConnection) -> Result<(), RunMigrationsError>;
-    fn file_path(&self) -> Option<&Path> {
-        None
-    }
-}
-
-#[allow(missing_debug_implementations)]
-#[derive(Clone, Copy)]
-pub struct MigrationName<'a> {
-    pub migration: &'a Migration,
-}
-
-pub fn name(migration: &Migration) -> MigrationName {
-    MigrationName {
-        migration: migration,
-    }
-}
-
-impl<'a> fmt::Display for MigrationName<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let file_name = self.migration
-            .file_path()
-            .and_then(|file_path| file_path.file_name())
-            .and_then(|file| file.to_str());
-        if let Some(name) = file_name {
-            f.write_str(name)?;
-        } else {
-            f.write_str(self.migration.version())?;
-        }
-        Ok(())
+pub fn migration_from(path: PathBuf) -> Result<Box<Migration>, MigrationError> {
+    #[cfg(feature = "barrel")]
+    match ::barrel::diesel::migration_from(&path) {
+        Some(migration) => return Ok(migration),
+        None => {}
     }
-}
 
-pub fn migration_from(path: PathBuf) -> Result<Box<Migration>, MigrationError> {
     if valid_sql_migration_directory(&path) {
         let version = try!(version_from_path(&path));
         Ok(Box::new(SqlFileMigration(path, version)))
@@ -49,40 +18,6 @@ pub fn migration_from(path: PathBuf) -> Result<Box<Migration>, MigrationError> {
     }
 }
 
-impl Migration for Box<Migration> {
-    fn version(&self) -> &str {
-        (&**self).version()
-    }
-
-    fn run(&self, conn: &SimpleConnection) -> Result<(), RunMigrationsError> {
-        (&**self).run(conn)
-    }
-
-    fn revert(&self, conn: &SimpleConnection) -> Result<(), RunMigrationsError> {
-        (&**self).revert(conn)
-    }
-    fn file_path(&self) -> Option<&Path> {
-        (&**self).file_path()
-    }
-}
-
-impl<'a> Migration for &'a Migration {
-    fn version(&self) -> &str {
-        (&**self).version()
-    }
-
-    fn run(&self, conn: &SimpleConnection) -> Result<(), RunMigrationsError> {
-        (&**self).run(conn)
-    }
-
-    fn revert(&self, conn: &SimpleConnection) -> Result<(), RunMigrationsError> {
-        (&**self).revert(conn)
-    }
-    fn file_path(&self) -> Option<&Path> {
-        (&**self).file_path()
-    }
-}
-
 fn valid_sql_migration_directory(path: &Path) -> bool {
     file_names(path)
         .map(|files| files.contains(&"down.sql".into()) && files.contains(&"up.sql".into()))