MigrationCreator.php

TLDR

This file is a part of the Illuminate\Database\Migrations namespace in the Demo Projects project. It contains the MigrationCreator class, which is responsible for creating new migrations. It has various methods for creating and manipulating migration files.

Methods

__construct(Filesystem $files, $customStubPath)

This is the constructor method for the MigrationCreator class. It takes two parameters, $files of type Filesystem and $customStubPath of type string, and initializes the corresponding properties.

create($name, $path, $table = null, $create = false)

This method creates a new migration file at the given path. It takes four parameters: $name of type string, $path of type string, $table of type string or null, and $create of type boolean. It ensures that a migration with the same name doesn't already exist, gets the stub file for the migration, generates the path for the new migration file, saves the file with the populated stub content, and fires any post create hooks.

ensureMigrationDoesntAlreadyExist($name, $migrationPath = null)

This method ensures that a migration with the given name doesn't already exist. It takes two parameters: $name of type string and $migrationPath of type string or null. It checks if the migration file already exists in the specified migration path and throws an exception if it does.

getStub($table, $create)

This method gets the appropriate stub file for the migration based on the provided table and create flags. It takes two parameters: $table of type string or null and $create of type boolean. It determines the stub file based on the table and create flags and returns the content of the stub file.

populateStub($stub, $table)

This method populates the placeholders in the migration stub with the provided table name. It takes two parameters: $stub of type string and $table of type string or null. It replaces the placeholders in the stub with the provided table name and returns the populated stub content.

getClassName($name)

This method generates the class name based on the provided migration name. It takes one parameter: $name of type string and uses the Str::studly method from the Illuminate\Support\Str class to convert the migration name to a studly case string.

getPath($name, $path)

This method generates the full path for the new migration file based on the provided name and path parameters. It takes two parameters: $name of type string and $path of type string and returns the full path string.

firePostCreateHooks($table, $path)

This method fires any registered post create hooks with the provided table name and path. It takes two parameters: $table of type string or null and $path of type string. It iterates over the registered post create callbacks and calls each of them with the table name and path as parameters.

afterCreate(Closure $callback)

This method registers a post migration create hook. It takes one parameter: $callback of type Closure. It adds the provided callback to the postCreate array for later execution.

getDatePrefix()

This method returns the date prefix for the migration in the format "Y_m_d_His". It takes no parameters and uses the date function to generate the current date and time in a specific format.

stubPath()

This method returns the path to the stub files for the migrations. It takes no parameters and returns a string representing the path.

getFilesystem()

This method returns the Filesystem instance used by the MigrationCreator class. It takes no parameters and returns the files property.

<?php

namespace Illuminate\Database\Migrations;

use Closure;
use Illuminate\Filesystem\Filesystem;
use Illuminate\Support\Str;
use InvalidArgumentException;

class MigrationCreator
{
    /**
     * The filesystem instance.
     *
     * @var \Illuminate\Filesystem\Filesystem
     */
    protected $files;

    /**
     * The custom app stubs directory.
     *
     * @var string
     */
    protected $customStubPath;

    /**
     * The registered post create hooks.
     *
     * @var array
     */
    protected $postCreate = [];

    /**
     * Create a new migration creator instance.
     *
     * @param  \Illuminate\Filesystem\Filesystem  $files
     * @param  string  $customStubPath
     * @return void
     */
    public function __construct(Filesystem $files, $customStubPath)
    {
        $this->files = $files;
        $this->customStubPath = $customStubPath;
    }

    /**
     * Create a new migration at the given path.
     *
     * @param  string  $name
     * @param  string  $path
     * @param  string|null  $table
     * @param  bool  $create
     * @return string
     *
     * @throws \Exception
     */
    public function create($name, $path, $table = null, $create = false)
    {
        $this->ensureMigrationDoesntAlreadyExist($name, $path);

        // First we will get the stub file for the migration, which serves as a type
        // of template for the migration. Once we have those we will populate the
        // various place-holders, save the file, and run the post create event.
        $stub = $this->getStub($table, $create);

        $path = $this->getPath($name, $path);

        $this->files->ensureDirectoryExists(dirname($path));

        $this->files->put(
            $path, $this->populateStub($stub, $table)
        );

        // Next, we will fire any hooks that are supposed to fire after a migration is
        // created. Once that is done we'll be ready to return the full path to the
        // migration file so it can be used however it's needed by the developer.
        $this->firePostCreateHooks($table, $path);

        return $path;
    }

    /**
     * Ensure that a migration with the given name doesn't already exist.
     *
     * @param  string  $name
     * @param  string  $migrationPath
     * @return void
     *
     * @throws \InvalidArgumentException
     */
    protected function ensureMigrationDoesntAlreadyExist($name, $migrationPath = null)
    {
        if (! empty($migrationPath)) {
            $migrationFiles = $this->files->glob($migrationPath.'/*.php');

            foreach ($migrationFiles as $migrationFile) {
                $this->files->requireOnce($migrationFile);
            }
        }

        if (class_exists($className = $this->getClassName($name))) {
            throw new InvalidArgumentException("A {$className} class already exists.");
        }
    }

    /**
     * Get the migration stub file.
     *
     * @param  string|null  $table
     * @param  bool  $create
     * @return string
     */
    protected function getStub($table, $create)
    {
        if (is_null($table)) {
            $stub = $this->files->exists($customPath = $this->customStubPath.'/migration.stub')
                            ? $customPath
                            : $this->stubPath().'/migration.stub';
        } elseif ($create) {
            $stub = $this->files->exists($customPath = $this->customStubPath.'/migration.create.stub')
                            ? $customPath
                            : $this->stubPath().'/migration.create.stub';
        } else {
            $stub = $this->files->exists($customPath = $this->customStubPath.'/migration.update.stub')
                            ? $customPath
                            : $this->stubPath().'/migration.update.stub';
        }

        return $this->files->get($stub);
    }

    /**
     * Populate the place-holders in the migration stub.
     *
     * @param  string  $stub
     * @param  string|null  $table
     * @return string
     */
    protected function populateStub($stub, $table)
    {
        // Here we will replace the table place-holders with the table specified by
        // the developer, which is useful for quickly creating a tables creation
        // or update migration from the console instead of typing it manually.
        if (! is_null($table)) {
            $stub = str_replace(
                ['DummyTable', '{{ table }}', '{{table}}'],
                $table, $stub
            );
        }

        return $stub;
    }

    /**
     * Get the class name of a migration name.
     *
     * @param  string  $name
     * @return string
     */
    protected function getClassName($name)
    {
        return Str::studly($name);
    }

    /**
     * Get the full path to the migration.
     *
     * @param  string  $name
     * @param  string  $path
     * @return string
     */
    protected function getPath($name, $path)
    {
        return $path.'/'.$this->getDatePrefix().'_'.$name.'.php';
    }

    /**
     * Fire the registered post create hooks.
     *
     * @param  string|null  $table
     * @param  string  $path
     * @return void
     */
    protected function firePostCreateHooks($table, $path)
    {
        foreach ($this->postCreate as $callback) {
            $callback($table, $path);
        }
    }

    /**
     * Register a post migration create hook.
     *
     * @param  \Closure  $callback
     * @return void
     */
    public function afterCreate(Closure $callback)
    {
        $this->postCreate[] = $callback;
    }

    /**
     * Get the date prefix for the migration.
     *
     * @return string
     */
    protected function getDatePrefix()
    {
        return date('Y_m_d_His');
    }

    /**
     * Get the path to the stubs.
     *
     * @return string
     */
    public function stubPath()
    {
        return __DIR__.'/stubs';
    }

    /**
     * Get the filesystem instance.
     *
     * @return \Illuminate\Filesystem\Filesystem
     */
    public function getFilesystem()
    {
        return $this->files;
    }
}