static void printAllMigrations(IMigration[] migrations) {
     foreach (var m in migrations) {
         Console.WriteLine("========================================");
         Console.WriteLine(m.version + "\n  - " + m.description + "\n  - Use on folder, " + m.workingDirectory);
     }
     Console.WriteLine("========================================");
 }

 public MigrationWithMetaDataAdapter(IMigration migration, IMigrationMetadata metadata)
 {
     if (migration == null) throw new ArgumentNullException("migration");
     if (metadata == null) throw new ArgumentNullException("metadata");
     Migration = migration;
     MetaData = metadata;
 }

        static void migrate(IMigration migration)
        {
            var shouldMigrate = EditorUtility.DisplayDialog("Migrate",
                                    "You are about to migrate your source files. " +
                                    "Make sure that you have committed your current project or that you have a backup of your project before you proceed.",
                                    "I have a backup - Migrate",
                                    "Cancel"
                                );

            if(shouldMigrate) {
                EditorUtility.DisplayDialog("Migrate",
                    "Please select the folder, " + migration.workingDirectory + ".",
                    "I will select the requested folder"
                );

                var path = "Assets/";
                path = EditorUtility.OpenFolderPanel(migration.version + ": " + migration.workingDirectory, path, string.Empty);
                if(!string.IsNullOrEmpty(path)) {
                    var changedFiles = migration.Migrate(path);
                    Debug.Log("Applying " + migration.version);
                    foreach(var file in changedFiles) {
                        MigrationUtils.WriteFiles(changedFiles);
                        Debug.Log("Migrated " + file.fileName);
                    }
                } else {
                    throw new Exception("Could not complete migration! Selected path was invalid!");
                }
            }
        }

 static void printUsage(IMigration[] migrations)
 {
     Console.WriteLine(@"usage:
     [-l]             - print all available versions
     [version] [path] - apply migration of version [version] to source files located at [path]"
     );
 }

        public static void Main(string[] args)
        {
            var allMigrations = new IMigration[] {
                new M0180(),
                new M0190(),
                new M0220(),
                new M0260(),
                new M0300()
            };

            if (args == null) {
                printUsage(allMigrations);
            } else if (args.Length == 1) {
                var arg = args[0];
                if (arg == "-l") {
                    printAllMigrations(allMigrations);
                } else {
                    printUsage(allMigrations);
                }
            } else if (args.Length == 2) {
                var version = args[0];
                var path = args[1];
                var migrations = allMigrations.Where(m => m.version == version).ToArray();
                if (migrations.Length == 0) {
                    printVersionNotFound(version, allMigrations);
                } else {
                    foreach (var m in migrations) {
                        MigrationUtils.WriteFiles(m.Migrate(path));
                    }
                }
            } else {
                printUsage(allMigrations);
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="AfterMigrationEventArgs"/> class.
 /// </summary>
 /// <param name="version">The version.</param>
 /// <param name="migration">The migration.</param>
 /// <param name="direction">The direction.</param>
 /// <param name="success">if set to <c>true</c> the migration succeeded.</param>
 public AfterMigrationEventArgs(long version, IMigration migration, MigrationDirection direction, bool success)
 {
     Version = version;
     Migration = migration;
     Direction = direction;
     Success = success;
 }

 private long ExtractTimestamp(string moduleName, IMigration migration)
 {
     var timestampProvider = _timestampProviders.ContainsKey(moduleName)
         ? _timestampProviders[moduleName]
         : _timestampProviders[MigrationExportAttribute.DefaultModuleName];
     long timestamp = timestampProvider.GetTimestamp(migration.GetType());
     return timestamp;
 }

 public MigrationStep(IMigration migration, IScheduledMigrationMetadata metadata, ConnectionInfo connectionInfo, IProvider provider, IProviderMetadata providerMetadata, IDbConnectionFactory connectionFactory, ISqlDispatcher sqlDispatcher)
     : base(migration, provider, providerMetadata)
 {
     _metadata = metadata;
     _connectionInfo = connectionInfo;
     _connectionFactory = connectionFactory;
     _sqlDispatcher = sqlDispatcher;
 }

        public MigrationInfo(long version, TransactionBehavior transactionBehavior, IMigration migration)
        {
            if (migration == null) throw new ArgumentNullException("migration");

            Version = version;
            TransactionBehavior = transactionBehavior;
            Migration = migration;
        }

        public MigrationInfo(long version, TransactionBehavior transactionBehavior, bool breakingChange, IMigration migration)
        {
            if (migration == null) throw new ArgumentNullException("migration");

            Version = version;
            TransactionBehavior = transactionBehavior;
            Migration = migration;
            BreakingChange = breakingChange;
        }

		private void ApplyMigration(IMigration migration, MigrationAttribute attr) {
			// we're adding this one
			_logger.MigrateUp(Current, migration.Name);
			if (! DryRun) {
				migration.Up();
				_provider.MigrationApplied(attr.Version);
				_provider.Commit();
				migration.AfterUp();
			}
		}

 public MigrationVersionRunner(IMigrationConventions conventions, IMigrationProcessor processor, IMigrationLoader loader, Assembly assembly, string @namespace)
 {
     _migrationConventions = conventions;
     _migrationProcessor = processor;
     _migrationAssembly = assembly;
     _migrationLoader = loader;
     _namespace = @namespace;
     _migrationRunner = new MigrationRunner(conventions, processor);
        _versionMigration = new VersionMigration();
 }

		private void RemoveMigration(IMigration migration, MigrationAttribute attr) {
			// we're removing this one
			_logger.MigrateDown(Current, migration.Name);
			if (! DryRun) {
				migration.Down();
				_provider.MigrationUnApplied(attr.Version);
				_provider.Commit();
				migration.AfterDown();
			}
		}

 public override void Migrate(IMigration migration)
 {
     _provider.BeginTransaction();
     MigrationAttribute attr = (MigrationAttribute)Attribute.GetCustomAttribute(migration.GetType(), typeof(MigrationAttribute));
     
     if (_provider.AppliedMigrations.Contains(attr.Version)) {
     	RemoveMigration(migration, attr);
     } else {
     	ApplyMigration(migration, attr);
     }
 }

 private void SolveDependency(IDbRoot root, string filePath, IMigration migration)
 {
     foreach (var migrationId in migration.MigrationsNeeded.Where(x => !root.MigrationHistory.HasMigration(x)))
     {
         // For each dependency that needs to be solved, we solve the subdependencies
         var dependency = this.migrations[migrationId];
         this.SolveDependency(root, filePath, dependency);
         dependency.Apply(root, filePath);
         root.MigrationHistory.AddMigration(migrationId);
     }
 }

 private Task Migrate(IMigration migration, Func<IMigration, Task> action)
 {
     try
     {
         return action(migration);
     }
     finally
     {
         var disposable = migration as IDisposable;
         disposable?.Dispose();
     }
 }

 public MigrationVersionRunner(IMigrationConventions conventions, IMigrationProcessor processor, IMigrationLoader loader, Assembly assembly, string @namespace, IAnnouncer announcer)
 {
     _migrationConventions = conventions;
     _migrationProcessor = processor;
     _migrationAssembly = assembly;
     _migrationLoader = loader;
     _namespace = @namespace;
     _announcer = announcer;
     _migrationRunner = new MigrationRunner(conventions, processor, announcer, new StopWatch());
     _versionTableMetaData = loader.GetVersionTableMetaData(assembly);
     _versionMigration = new VersionMigration(_versionTableMetaData);
 }

        public VersionLoader(IMigrationRunner runner, IAssemblyCollection assemblies, IMigrationConventions conventions)
        {
            Runner = runner;
            Processor = runner.Processor;
            Assemblies = assemblies;

            Conventions = conventions;
            VersionTableMetaData = GetVersionTableMetaData();
            VersionMigration = new VersionMigration(VersionTableMetaData);
            VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
            VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
            VersionDescriptionMigration = new VersionDescriptionMigration(VersionTableMetaData);

            LoadVersionInfo();
        }

        /// <summary>
        /// Alters the database schema by applying the specified migration. Versioning is unaffected by this operation and any timestamp information on the <paramref name="migration"/> is disregarded.
        /// </summary>
        public void Alter(IMigration migration)
        {
            if (migration is IReversibleMigration)
            {
                Log.Info(LogCategory.General, "Migrations used to modify the database schema directly cannot be reversed.");
            }

            var migrationMetadata = new MigrationMetadata(0, "Bypass", "This migration is being executed without affecting the versioning.");
            var stepMetadata = new MigrationStepMetadata(MigrationDirection.Up, false, new[] { migrationMetadata });
            var batch = new MigrationBatch(new[]
            {
                new MigrationStep(migration, stepMetadata)
            }, Enumerable.Empty<IMigrationMetadata>(), new NoVersioning(), Configuration);
            batch.Execute();
        }

		void ApplyMigration(IMigration migration, MigrationAttribute attr)
		{
			// we're adding this one
			_logger.MigrateUp(Current, migration.Name);
			if (! DryRun)
			{
                var tProvider = _provider as TransformationProvider;
			    if (tProvider != null) 
                    tProvider.CurrentMigration = migration;

				migration.Up();
                _provider.MigrationApplied(attr.Version, attr.Scope);
				_provider.Commit();
				migration.AfterUp();
			}
		}