Illuminate\Database\Migrations\Migrator::runUp() | 関連メソッド

    /**
     * Run "up" a migration instance.
     *
     * @param  string  $file
     * @param  int  $batch
     * @param  bool  $pretend
     * @return void
     */
    protected function runUp($file, $batch, $pretend)
    {
        // First we will resolve a "real" instance of the migration class from this
        // migration file name. Once we have the instances we can run the actual
        // command such as "up" or "down", or we can just simulate the action.
        $migration = $this->resolve(
            $name = $this->getMigrationName($file)
        );

        if ($pretend) {
            return $this->pretendToRun($migration, 'up');
        }

        $this->note("Migrating: {$name}");

        $startTime = microtime(true);

        $this->runMigration($migration, 'up');

        $runTime = round(microtime(true) - $startTime, 2);

        // Once we have run a migrations class, we will log that it was run in this
        // repository so that we don't try to run it next time we do a migration
        // in the application. A migration repository keeps the migrate order.
        $this->repository->log($name, $batch);

        $this->note("Migrated:  {$name} ({$runTime} seconds)");
    }
    /**
     * Resolve a migration instance from a file.
     *
     * @param  string  $file
     * @return object
     */
    public function resolve($file)
    {
        $class = Str::studly(implode('_', array_slice(explode('_', $file), 4)));

        return new $class;
    }
    /**
     * Get the name of the migration.
     *
     * @param  string  $path
     * @return string
     */
    public function getMigrationName($path)
    {
        return str_replace('.php', '', basename($path));
    }

以前読んだ処理の中で、実行対象のマイグレーションファイルは require_once() で読み込まれていました。
それを実行する手続きを踏むはずです。
getMigrationName() メソッドで拡張子を削除します。
resolve() メソッドでクラス名を取り出します。
マイグレーションファイルはファイルの前半に生成した日付の情報が数字とアンダースコアで連結してあります。まずこれを取り除きます。その後 Str::studly() メソッドでパスカルケースのクラス名に変換しつつキャッシュします。
出来たクラス名を使い生成したインスタンスを変数 $migration に代入します。
次に、 $pretend が true ならば、pretendToRun() メソッドをコールします。
これはおそらくドライランのような使い方をするのでしょう。今回は通りません。
note() メソッドでメッセージを出力します。「Migrating: 2014_10_12_000000_create_users_table」 のような感じですね。

変数 $startTime にクエリ開始時間を代入します。

runMigration() メソッドを実行します。

Illuminate\Database\Migrations\Migrator::runMigration()

    /**
     * Run a migration inside a transaction if the database supports it.
     *
     * @param  object  $migration
     * @param  string  $method
     * @return void
     */
    protected function runMigration($migration, $method)
    {
        $connection = $this->resolveConnection(
            $migration->getConnection()
        );

        $callback = function () use ($migration, $method) {
            if (method_exists($migration, $method)) {
                $this->fireMigrationEvent(new MigrationStarted($migration, $method));

                $migration->{$method}();

                $this->fireMigrationEvent(new MigrationEnded($migration, $method));
            }
        };

        $this->getSchemaGrammar($connection)->supportsSchemaTransactions()
            && $migration->withinTransaction
                    ? $connection->transaction($callback)
                    : $callback();
    }

resolveConnection() メソッドで接続を変数 $connection に代入します。
変数 $callback にコールバックを代入しています。メイン処理を行うクロージャーです。
getSchemaGrammar() メソッドでスキーマグラマーを取得しています。
今回は MySqlGrammar ですね。
取得した MySqlGrammar の supportsSchemaTransactions() メソッドをコールしています。

Illuminate\Database\Schema\Grammars\Grammar::supportsSchemaTransactions()

    /**
     * Check if this Grammar supports schema changes wrapped in a transaction.
     *
     * @return bool
     */
    public function supportsSchemaTransactions()
    {
        return $this->transactions;
    }

supportsSchemaTransactions() メソッドは $this->transactions を戻しているだけです。
Grammar クラスのこのパラメータの初期値は false です。継承している MySqlGrammar もこのパラメータを上書きはしていません。おそらく、現状の Laravel のグラマーはトランザクションをカバーしていないのでしょう。
このパラメーターが true 且つ 対象マイグレーションインスタンスの $withinTransaction パラメーターが true だった場合、接続の transaction() メソッドにコールバックを渡します。
そうでない場合はコルバックをそのまま実行します。
マイグレーションファイルのスーパークラスとなる Illuminate\Database\Migrations\Migration クラスの $withinTransaction パラメータの初期値は true となっています。

Illuminate\Database\Concerns\ManagesTransactions::transactionI()

    /**
     * Execute a Closure within a transaction.
     *
     * @param  \Closure  $callback
     * @param  int  $attempts
     * @return mixed
     *
     * @throws \Throwable
     */
    public function transaction(Closure $callback, $attempts = 1)
    {
        for ($currentAttempt = 1; $currentAttempt <= $attempts; $currentAttempt++) {
            $this->beginTransaction();

            // We'll simply execute the given callback within a try / catch block and if we
            // catch any exception we can rollback this transaction so that none of this
            // gets actually persisted to a database or stored in a permanent fashion.
            try {
                $callbackResult = $callback($this);
            }

            // If we catch an exception we'll rollback this transaction and try again if we
            // are not out of attempts. If we are out of attempts we will just throw the
            // exception back out and let the developer handle an uncaught exceptions.
            catch (Throwable $e) {
                $this->handleTransactionException(
                    $e, $currentAttempt, $attempts
                );

                continue;
            }

            try {
                $this->commit();
            } catch (Throwable $e) {
                $this->handleCommitTransactionException(
                    $e, $currentAttempt, $attempts
                );

                continue;
            }

            return $callbackResult;
        }
    }

一応 transaction() メソッドも見てみましょう。 beginTransaction() メソッドをコールしてコールバックを実行し、 commit() メソッドをコールしています。
流れはわかりますね。今回はここは通りません。

コールバックの実行に入ります。クロージャーを読みましょう。以下のようの内容です。

function () use ($migration, $method) {
    if (method_exists($migration, $method)) {
        $this->fireMigrationEvent(new MigrationStarted($migration, $method));
        $migration->{$method}();
        $this->fireMigrationEvent(new MigrationEnded($migration, $method));
    }
};

引数として渡されたマイグレーションクラスとメソッド名が実行可能か検証し、可能なら処理をします。
fireMigrationEvent() はイベントをディスパッチするものでした。
マイグレーション開始と終了のクラスをディスパッチする間で対象メソッドが実行されています。

今回のマイグレーション実行予定は以下のようなものでした。

2014_10_12_000000_create_users_table.php
2019_08_19_000000_create_failed_jobs_table.php
2020_03_23_050035_create_customers_table.php

create_users_table.php を見てみましょう。

class CreateUsersTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('users', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('email')->unique();
            $table->timestamp('email_verified_at')->nullable();
            $table->string('password');
            $table->rememberToken();
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('users');
    }
}

Schema::create() を見てみましょう。
もはや懐かしいですね。初期の頃に Facade::__callStatic() から static::$app['db']->connection()->getSchemaBuilder() がコールされ、戻り値の create() メソッドがコールされるんでしたね。

Illuminate\Database\Schema\Builder::create() | createBlueprint()

    /**
     * Create a new table on the schema.
     *
     * @param  string  $table
     * @param  \Closure  $callback
     * @return void
     */
    public function create($table, Closure $callback)
    {
        $this->build(tap($this->createBlueprint($table), function ($blueprint) use ($callback) {
            $blueprint->create();

            $callback($blueprint);
        }));
    }
    /**
     * Create a new command set with a Closure.
     *
     * @param  string  $table
     * @param  \Closure|null  $callback
     * @return \Illuminate\Database\Schema\Blueprint
     */
    protected function createBlueprint($table, Closure $callback = null)
    {
        $prefix = $this->connection->getConfig('prefix_indexes')
                    ? $this->connection->getConfig('prefix')
                    : '';

        if (isset($this->resolver)) {
            return call_user_func($this->resolver, $table, $callback, $prefix);
        }

        return new Blueprint($table, $callback, $prefix);
    }

createBlueprint() メソッドは、Blueprint インスタンスをテーブル名とクロージャー、プレフィックスを引数として渡して生成し戻しています。

tap() ヘルパ関数は第一引数を第二引数のクロージャーに引数として渡してコールします。
クロージャーでは、渡された Blueprint インスタンスの create() メソッドをコールしています。

Illuminate\Database\Schema\Blueprint::create()

    /**
     * Indicate that the table needs to be created.
     *
     * @return \Illuminate\Support\Fluent
     */
    public function create()
    {
        return $this->addCommand('create');
    }

create コマンドを追加していますね。
その後、 create() メソッドに渡された クロージャーを自身を引数として渡してコールしています。
ややこしいですね。
つまり、マイグレーションファイルのに定義されているクラス、今回は CreateUsersTable の up() メソッドの第二引数として渡されているクロージャーです。テーブルにカラムを追加する処理が入っているようです。

tap() ヘルパ関数は第二引数に渡した第一引数を戻します。
こうして手続きを踏んだ Blueprint インスタンスを引数として渡して build() メソッドがコールされます。

SQL文を構築するメソッドを見てみましょう。

Illuminate\Database\Schema\Blueprint SQL生成用メソッド

    public function id($column = 'id')
    {
        return $this->bigIncrements($column);
    }
    public function bigIncrements($column)
    {
        return $this->unsignedBigInteger($column, true);
    }
    public function unsignedBigInteger($column, $autoIncrement = false)
    {
        return $this->bigInteger($column, $autoIncrement, true);
    }
    public function bigInteger($column, $autoIncrement = false, $unsigned = false)
    {
        return $this->addColumn('bigInteger', $column, compact('autoIncrement', 'unsigned'));
    }
    public function addColumn($type, $name, array $parameters = [])
    {
        $this->columns[] = $column = new ColumnDefinition(
            array_merge(compact('type', 'name'), $parameters)
        );

        return $column;
    }
    public function string($column, $length = null)
    {
        $length = $length ?: Builder::$defaultStringLength;

        return $this->addColumn('string', $column, compact('length'));
    }
    public function timestamp($column, $precision = 0)
    {
        return $this->addColumn('timestamp', $column, compact('precision'));
    }
    public function rememberToken()
    {
        return $this->string('remember_token', 100)->nullable();
    }
    public function timestamps($precision = 0)
    {
        $this->timestamp('created_at', $precision)->nullable();

        $this->timestamp('updated_at', $precision)->nullable();
    }

以下のようなSQLが生成されそうです。

CREATE TABLE users (
    id bigint unsigned auto_increment primary key not null,
    name varchar(255) not null,
    email varchar(255) not null,
    email_verified_at timestamp null,
    password varchar(255) not null,
    remember_token varchar(100) null,
    created_at timestamp null,
    updated_at timestamp null
);
ALTER TABLE users ADD unique users_email_unique (email);

残りのファイルも見てみましょう。

PROJECT_ROOT\database\magrations\2019_08_19_000000_create_failed_jobs_table.php

class CreateFailedJobsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('failed_jobs', function (Blueprint $table) {
            $table->id();
            $table->text('connection');
            $table->text('queue');
            $table->longText('payload');
            $table->longText('exception');
            $table->timestamp('failed_at')->useCurrent();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('failed_jobs');
    }
}

以下のようなSQLが生成されそうです。

CREATE TABLE failed_jobs (
    id bigint unsigned auto_increment primary key not null,
    connection text not null,
    queue text not null,
    payload longtext not null,
    exception longtext not null,
    failed_at timestamp  default CURRENT_TIMESTAMP
);

PROJECT_ROOT\database\magrations\2020_03_23_050035_create_customers_table.php

class CreateCustomersTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('customers', function (Blueprint $table) {
            $table->id();
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('customers');
    }
}

以下のようなSQLが生成されそうです。

CREATE TABLE customers (
    id bigint unsigned auto_increment primary key not null,
    created_at timestamp null,
    updated_at timestamp null
);

生成されたSQLを実行しテーブルを３つ作成します。
生成後、現在時間から、処理開始時間を引き、実行にかかった時間を割り出します。
$this->repository 、つまり DatabaseMigrationRepository インスタンスの log() メソッドをマイグレーション名とバッチ番号を引数として渡しコールします。

Illuminate\Database\Migrations\DatabaseMigrationRepository::log()

    /**
     * Log that a migration was run.
     *
     * @param  string  $file
     * @param  int  $batch
     * @return void
     */
    public function log($file, $batch)
    {
        $record = ['migration' => $file, 'batch' => $batch];

        $this->table()->insert($record);
    }

Illuminate\Database\Query\Builder::insert()

    /**
     * Insert a new record into the database.
     *
     * @param  array  $values
     * @return bool
     */
    public function insert(array $values)
    {
        // Since every insert gets treated like a batch insert, we will make sure the
        // bindings are structured in a way that is convenient when building these
        // inserts statements by verifying these elements are actually an array.
        if (empty($values)) {
            return true;
        }

        if (! is_array(reset($values))) {
            $values = [$values];
        }

        // Here, we will sort the insert keys for every record so that each insert is
        // in the same order for the record. We need to make sure this is the case
        // so there are not any errors or problems when inserting these records.
        else {
            foreach ($values as $key => $value) {
                ksort($value);

                $values[$key] = $value;
            }
        }

        // Finally, we will run this query against the database connection and return
        // the results. We will need to also flatten these bindings before running
        // the query so they are all in one huge, flattened array for execution.
        return $this->connection->insert(
            $this->grammar->compileInsert($this, $values),
            $this->cleanBindings(Arr::flatten($values, 1))
        );
    }

Illuminate\Database\Query\Grammars\MySqlGrammar::compileInsert()

    /**
     * Compile an insert statement into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $values
     * @return string
     */
    public function compileInsert(Builder $query, array $values)
    {
        if (empty($values)) {
            $values = [[]];
        }

        return parent::compileInsert($query, $values);
    }

Illuminate\Database\Query\Grammars\MySqlGrammar::compileInsert()

    /**
     * Compile an insert statement into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $values
     * @return string
     */
    public function compileInsert(Builder $query, array $values)
    {
        // Essentially we will force every insert to be treated as a batch insert which
        // simply makes creating the SQL easier for us since we can utilize the same
        // basic routine regardless of an amount of records given to us to insert.
        $table = $this->wrapTable($query->from);

        if (empty($values)) {
            return "insert into {$table} default values";
        }

        if (! is_array(reset($values))) {
            $values = [$values];
        }

        $columns = $this->columnize(array_keys(reset($values)));

        // We need to build a list of parameter place-holders of values that are bound
        // to the query. Each insert should have the exact same amount of parameter
        // bindings so we will loop through the record and parameterize them all.
        $parameters = collect($values)->map(function ($record) {
            return '('.$this->parameterize($record).')';
        })->implode(', ');

        return "insert into $table ($columns) values $parameters";
    }

もう読むのは難しくありませんね。

以下のようなSQLが生成されそうです。

INSERT INTO migrations (migration, batch) values (FILE_NAME, BATCH_NO);

その後、note() メソッドを引数に 「Migrated: マイグレーション名 (実行時間 seconds)」 というメッセージを渡しコールしてメッセージを出力し Migrator::runUp() メソッドは完了です。

runUp() メソッドの処理が終わると、runPending() メソッドは fireMigrationEvent() メソッドでマイグレーション終了をディスパッチして終了します。
runPending() メソッドの実行が狩猟すると、Migrator::run() メソッドはマイグレーションファイル配列を戻します。
コール元は MigrateCommand::handle() でした。マイグレーション処理完了後、 0 を戻します。

MigrateCommand::handle() メソッドのコール元は Command::execute() でした。
受け取った値をそのまま戻します。
Command::execute() メソッドのコール元は Symfony\Component\Console\Command\Command::run() でした。
Symfony\Component\Console\Command\Command::run() メソッドは戻り値が整数ならそれを、そうでなけれが 0 を戻します。
Symfony\Component\Console\Command\Command::run() メソッドのコール元は Illuminate\Console\Command::run() でした。Illuminate\Console\Command::run() は受け取った戻り値をそのまま戻します。
Illuminate\Console\Command::run() のコール元は Symfony\Component\Console\Application::doRunCommand() です。
Symfony\Component\Console\Application::doRunCommand() は受け取った戻り値をそのまま戻します。
Symfony\Component\Console\Application::doRunCommand() のコール元は Symfony\Component\Console\Application::doRun() です。
Symfony\Component\Console\Application::doRun() は $this->runningCommand を null に上書きし、戻り値を戻します。
Symfony\Component\Console\Application::doRun() のコール元は Symfony\Component\Console\Application::run() です。
Symfony\Component\Console\Application::run() は受け取った戻り値をそのまま戻します。
Symfony\Component\Console\Application::run() のコール元は Illuminate\Console\Application::run() です。
Illuminate\Console\Application::run() はイベントディスパッチャーにコマンド終了インスタンスをディスパッチした後、戻り値をそのまま戻します。
Illuminate\Console\Application::run() のコール元は Illuminate\Foundation\Console\Kernel::handle() です。
Illuminate\Foundation\Console\Kernel::handle() は戻り値をそのまま戻します。
Illuminate\Foundation\Console\Kernel::handle() のコール元は PROJECT_ROOT/artisan です。
PROJECT_ROOT/artisan は戻り値を変数 $status に代入します。
その後 terminate() メソッドを入力と戻り値のステータス値を引数に渡しコールします。

Illuminate\Foundation\Console\Kernel::terminate()

    /**
     * Terminate the application.
     *
     * @param  \Symfony\Component\Console\Input\InputInterface  $input
     * @param  int  $status
     * @return void
     */
    public function terminate($input, $status)
    {
        $this->app->terminate();
    }

Illuminate\Foundation\Application::terminate()

    /**
     * Terminate the application.
     *
     * @return void
     */
    public function terminate()
    {
        foreach ($this->terminatingCallbacks as $terminating) {
            $this->call($terminating);
        }
    }

terminate() メソッドはコマンド終了時にコールするコールバックが登録されていた場合はそれをコールします。
そしてとうとう、 exit() メソッドをステータス値を引数として渡してコールして終了です。
長い旅でした。お疲れさまです。

The post 【フレームワークを読む】Laravelのマイグレーションファイルは何をしているのか？ ：その１８：Migrator::runUp() appeared first on XIONCC.

Illuminate\Database\Migrations\Migrator::run()

    /**
     * Run the pending migrations at a given path.
     *
     * @param  array|string  $paths
     * @param  array  $options
     * @return array
     */
    public function run($paths = [], array $options = [])
    {
        // Once we grab all of the migration files for the path, we will compare them
        // against the migrations that have already been run for this package then
        // run each of the outstanding migrations against a database connection.
        $files = $this->getMigrationFiles($paths);

        $this->requireFiles($migrations = $this->pendingMigrations(
            $files, $this->repository->getRan()
        ));

        // Once we have all these migrations that are outstanding we are ready to run
        // we will go ahead and run them "up". This will execute each migration as
        // an operation against a database. Then we'll return this list of them.
        $this->runPending($migrations, $options);

        return $migrations;
    }

$this->repository->getRan() の戻り値は以下のSQLの結果を配列にしたものでした。

SELECT migration FROM migrations ORDER BY batch ASC, migration ASC

pendingMigrations() メソッドを見てみましょう。

Illuminate\Database\Migrations\Migrator::pendingMigrations()

    /**
     * Get the migration files that have not yet run.
     *
     * @param  array  $files
     * @param  array  $ran
     * @return array
     */
    protected function pendingMigrations($files, $ran)
    {
        return Collection::make($files)
                ->reject(function ($file) use ($ran) {
                    return in_array($this->getMigrationName($file), $ran);
                })->values()->all();
    }

Illuminate\Support\Traits\EnumeratesValues::reject()

    /**
     * Create a collection of all elements that do not pass a given truth test.
     *
     * @param  callable|mixed  $callback
     * @return static
     */
    public function reject($callback = true)
    {
        $useAsCallable = $this->useAsCallable($callback);

        return $this->filter(function ($value, $key) use ($callback, $useAsCallable) {
            return $useAsCallable
                ? ! $callback($value, $key)
                : $value != $callback;
        });
    }

マイグレーションファイル名の配列を引数として渡して Collection::make() メソッドをスタティックコールし、Collection インスタンスを生成したものの reject() メソッドをコールします。
引数として
reject() メソッドは受け取った引数がコールバックならば、それを使ってフィルターします。
マイグレーションファイル名の配列のなかで、先程のSQL実行結果に無いもののみを配列にしてそれを引数として生成した Collection インスタンスを戻します。

戻された Collection インスタンスを $migrations に代入し、requireFiles() メソッドをコールします。

Illuminate\Database\Migrations\Migrator::requireFiles()

    /**
     * Require in all the migration files in a given path.
     *
     * @param  array  $files
     * @return void
     */
    public function requireFiles(array $files)
    {
        foreach ($files as $file) {
            $this->files->requireOnce($file);
        }
    }

Illuminate\Filesystem\Filesystem::requireOnce()

    /**
     * Require the given file once.
     *
     * @param  string  $file
     * @return mixed
     */
    public function requireOnce($file)
    {
        require_once $file;
    }

requireFiles() メソッドは受け取ったファイル名配列を foreach で回して require_once() するだけですね。

さて、runPending() を読みましょう！

Illuminate\Database\Migrations\Migrator::runPending()

    /**
     * Run an array of migrations.
     *
     * @param  array  $migrations
     * @param  array  $options
     * @return void
     */
    public function runPending(array $migrations, array $options = [])
    {
        // First we will just make sure that there are any migrations to run. If there
        // aren't, we will just make a note of it to the developer so they're aware
        // that all of the migrations have been run against this database system.
        if (count($migrations) === 0) {
            $this->fireMigrationEvent(new NoPendingMigrations('up'));

            $this->note('Nothing to migrate.');

            return;
        }

        // Next, we will get the next batch number for the migrations so we can insert
        // correct batch number in the database migrations repository when we store
        // each migration's execution. We will also extract a few of the options.
        $batch = $this->repository->getNextBatchNumber();

        $pretend = $options['pretend'] ?? false;

        $step = $options['step'] ?? false;

        $this->fireMigrationEvent(new MigrationsStarted);

        // Once we have the array of migrations, we will spin through them and run the
        // migrations "up" so the changes are made to the databases. We'll then log
        // that the migration was run so we don't repeat it next time we execute.
        foreach ($migrations as $file) {
            $this->runUp($file, $batch, $pretend);

            if ($step) {
                $batch++;
            }
        }

        $this->fireMigrationEvent(new MigrationsEnded);
    }

引数として渡されているのは、マイグレーションファイル名の配列と、MigrateCommand::handle() メソッドから渡された第二引数の配列です。

Illuminate\Database\Console\Migrations\MigrateCommand::handle()

$this->migrator->setOutput($this->output)
    ->run($this->getMigrationPaths(), [
        'pretend' => $this->option('pretend'),
          'step' => $this->option('step'),
    ]);

Illuminate\Database\Migrations\Migrator::fireMigrationEvent() | note()

    /**
     * Fire the given event for the migration.
     *
     * @param  \Illuminate\Contracts\Database\Events\MigrationEvent  $event
     * @return void
     */
    public function fireMigrationEvent($event)
    {
        if ($this->events) {
            $this->events->dispatch($event);
        }
    }
    /**
     * Write a note to the console's output.
     *
     * @param  string  $message
     * @return void
     */
    protected function note($message)
    {
        if ($this->output) {
            $this->output->writeln($message);
        }
    }

runPending() に渡された第一引数、マイグレーションファイルの配列が空の場合、NoPendingMigrations インスタンスを引数に「up」を渡して生成したものを引数に fireMigrationEvent() メソッドをコールします。NoPendingMigrations クラスはコンストラクタに渡されたメソッド名のストリングを保持するだけの小さなクラスです。
fireMigrationEvent() メソッドはイベントにディスパッチしているだけですね。
そして note() メソッドを 「Nothing to migrate.」 をいうメッセージを引数にコールします。
これは、output->writeln() のラッパー関数ですね。メッセージを出力します。
メッセージを出力後に return します。

マイグレーションファイル配列に値が入っていた場合、DatabaseMigrationRepository インスタンスの getNextBatchNumber() メソッドをコールします。

Illuminate\Database\Migrations\DatabaseMigrationRepository::getNextBatchNumber()

    /**
     * Get the next migration batch number.
     *
     * @return int
     */
    public function getNextBatchNumber()
    {
        return $this->getLastBatchNumber() + 1;
    }
    /**
     * Get the last migration batch number.
     *
     * @return int
     */
    public function getLastBatchNumber()
    {
        return $this->table()->max('batch');
    }
    /**
     * Get a query builder for the migration table.
     *
     * @return \Illuminate\Database\Query\Builder
     */
    protected function table()
    {
        return $this->getConnection()->table($this->table)->useWritePdo();
    }

Illuminate\Database\Query\Builder::max()

    /**
     * Retrieve the maximum value of a given column.
     *
     * @param  string  $column
     * @return mixed
     */
    public function max($column)
    {
        return $this->aggregate(__FUNCTION__, [$column]);
    }
    /**
     * Execute an aggregate function on the database.
     *
     * @param  string  $function
     * @param  array  $columns
     * @return mixed
     */
    public function aggregate($function, $columns = ['*'])
    {
        $results = $this->cloneWithout($this->unions ? [] : ['columns'])
                        ->cloneWithoutBindings($this->unions ? [] : ['select'])
                        ->setAggregate($function, $columns)
                        ->get($columns);

        if (! $results->isEmpty()) {
            return array_change_key_case((array) $results[0])['aggregate'];
        }
    }

getNextBatchNumber() メソッドは getLastBatchNumber() メソッドの戻り値に１を加算した値を戻します。
getLastBatchNumber() メソッドは table() メソッドをコールして戻ってきた Builder インスタンスの max() メソッドをコールします。
table() メソッドは接続に対象テーブル名、今回は 「migrations」 をセットして書込PDO接続を指定しています。
max() メソッドは aggregate() メソッドを関数名「max」とカラム名を配列にしたもの、今回は 「['batch']」 を引数として渡してコールします。

aggregate() メソッドは SQL文を組み立てて実行していると推測されます。
一つずつ読んでみましょう。

Illuminate\Database\Query\Builder::cloneWithout()

    /**
     * Clone the query without the given properties.
     *
     * @param  array  $properties
     * @return static
     */
    public function cloneWithout(array $properties)
    {
        return tap(clone $this, function ($clone) use ($properties) {
            foreach ($properties as $property) {
                $clone->{$property} = null;
            }
        });
    }

cloneWithout() を ['columns'] を引数として渡してコールしています。
cloneWithout() は tap() ヘルパ関数を使い、自身のクローンを加工しています。
引数として渡された配列、今回は ['columns'] を foreach で回し、その値をプロパティー名としてクローンのプロパティーを null で上書きしています。つまり、指定カラム名をリセットすることになります。戻り値はクローンした Builder インスタンスです。

Illuminate\Database\Query\Builder::cloneWithoutBindings()

    /**
     * Clone the query without the given bindings.
     *
     * @param  array  $except
     * @return static
     */
    public function cloneWithoutBindings(array $except)
    {
        return tap(clone $this, function ($clone) use ($except) {
            foreach ($except as $type) {
                $clone->bindings[$type] = [];
            }
        });
    }

次は cloneWithoutBindings() メソッドを ['select'] を引数として渡してコールしています。
cloneWithoutBindings() も tap() ヘルパ関数を使い、自身のクローンを加工しています。
引数として渡された配列、今回は ['select'] を foreach で回し、クローンのバインドタイプを空配列に上書きしています。つまり、指定したバインドタイプをリセットすることになります。戻り値はクローンした Builder インスタンスです。

Illuminate\Database\Query\Builder::setAggregate()

    /**
     * Set the aggregate property without running the query.
     *
     * @param  string  $function
     * @param  array  $columns
     * @return $this
     */
    protected function setAggregate($function, $columns)
    {
        $this->aggregate = compact('function', 'columns');

        if (empty($this->groups)) {
            $this->orders = null;

            $this->bindings['order'] = [];
        }

        return $this;
    }

setAggregate() メソッドは受け取った引数を compact() で配列化し、$this->aggregate に代入します。この $this はクローンした Builder インスタンスです。
もし、 groups パラメーターが空だった場合、 orders を null に、bindings['order'] を空配列にセットし、自身を返します。

Illuminate\Database\Query\Builder::get()

    /**
     * Execute the query as a "select" statement.
     *
     * @param  array|string  $columns
     * @return \Illuminate\Support\Collection
     */
    public function get($columns = ['*'])
    {
        return collect($this->onceWithColumns(Arr::wrap($columns), function () {
            return $this->processor->processSelect($this, $this->runSelect());
        }));
    }

最後に get() メソッドを引数に ['batch'] を渡しコールします。
collect() ヘルパ関数を使い、結果を引数にして生成した Collection インスタンスを戻しています。中を見てみましょう。
onceWithColumns() メソッドをコールしています。これは少し前に読みましたね。引数として渡しているのは Arr::wrap() staticメソッドとクロージャーです。
Arr::wrap() は引数を配列にキャストして戻します。今回は 「['batch']」 ですのでそのままですね。
クロージャーは MySqlProcessor::processSelect() をコールしています。
引数に自身と $this->runSelect() を渡しています。

MySqlProcessor::processSelect() メソッドは第二引数をそのまま戻すものでした。
つまり、主役は $this->runSelect() ということになります。

もう一度見てみましょう。

Illuminate\Database\Query\Builder::runSelect()

    /**
     * Run the query as a "select" statement against the connection.
     *
     * @return array
     */
    protected function runSelect()
    {
        return $this->connection->select(
            $this->toSql(), $this->getBindings(), ! $this->useWritePdo
        );
    }

今回のポイントは aggregate が設定されているところだと思います。そこを主点に見てみましょう。

Illuminate\Database\Query\Builder::toSql()

    /**
     * Get the SQL representation of the query.
     *
     * @return string
     */
    public function toSql()
    {
        return $this->grammar->compileSelect($this);
    }

Illuminate\Database\Query\Grammars\Grammar::compileSelect() | 関連メソッド

    /**
     * The components that make up a select clause.
     *
     * @var array
     */
    protected $selectComponents = [
        'aggregate',
        'columns',
        'from',
        'joins',
        'wheres',
        'groups',
        'havings',
        'orders',
        'limit',
        'offset',
        'lock',
    ];
    /**
     * Compile a select query into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return string
     */
    public function compileSelect(Builder $query)
    {
        if ($query->unions && $query->aggregate) {
            return $this->compileUnionAggregate($query);
        }

        // If the query does not have any columns set, we'll set the columns to the
        // * character to just get all of the columns from the database. Then we
        // can build the query and concatenate all the pieces together as one.
        $original = $query->columns;

        if (is_null($query->columns)) {
            $query->columns = ['*'];
        }

        // To compile the query, we'll spin through each component of the query and
        // see if that component exists. If it does we'll just call the compiler
        // function for the component which is responsible for making the SQL.
        $sql = trim($this->concatenate(
            $this->compileComponents($query))
        );

        if ($query->unions) {
            $sql = $this->wrapUnion($sql).' '.$this->compileUnions($query);
        }

        $query->columns = $original;

        return $sql;
    }
    /**
     * Compile the components necessary for a select clause.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return array
     */
    protected function compileComponents(Builder $query)
    {
        $sql = [];

        foreach ($this->selectComponents as $component) {
            // To compile the query, we'll spin through each component of the query and
            // see if that component exists. If it does we'll just call the compiler
            // function for the component which is responsible for making the SQL.
            if (isset($query->$component) && ! is_null($query->$component)) {
                $method = 'compile'.ucfirst($component);

                $sql[$component] = $this->$method($query, $query->$component);
            }
        }

        return $sql;
    }

このあたりはだいぶ読みましたのでわりと読めるようになってきていると思います。
compileSelect() メソッドがコールされ、ロジックの手順を踏み compileComponents() メソッドがコールされます。
$this->selectComponents[] にはコンパイル対象のSQL句が格納されていてそれを foreach で回します。その中に今回のポイントとなる aggregate があります。ロジックの中で 「compileAggregate()」 というメソッド名が整形されそれを対象に Builder インスタンスと $query->aggregate が引数として渡されてコールされます。$query->aggregate の内容は以下のようなイメージです。

array(2) {
  ["function"]=>
  string(3) "max"
  ["columns"]=>
  string(5) "batch"
}

compileAggregate() メソッドを見てみましょう。

Illuminate\Database\Query\Grammars\Grammar::compileAggregate()

    /**
     * Compile an aggregated select clause.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $aggregate
     * @return string
     */
    protected function compileAggregate(Builder $query, $aggregate)
    {
        $column = $this->columnize($aggregate['columns']);

        // If the query has a "distinct" constraint and we're not asking for all columns
        // we need to prepend "distinct" onto the column name so that the query takes
        // it into account when it performs the aggregating operations on the data.
        if (is_array($query->distinct)) {
            $column = 'distinct '.$this->columnize($query->distinct);
        } elseif ($query->distinct && $column !== '*') {
            $column = 'distinct '.$column;
        }

        return 'select '.$aggregate['function'].'('.$column.') as aggregate';
    }

columnize() してます。これは $this->wrap() したものを implode() するものでした。特に変化はなさそうです。
次に $query->distinct パラメータを見ています。 DISTINCT句を使っているところはありませんのでここも通りません。
戻されるのは以下のようなSQLだと思います。

SELECT MAX(batch) as aggregate FROM migrations

SQL文を戻された compileComponents() メソッドは変数 $sql[] 配列に代入して戻します。
配列を戻された compileSelect() メソッドは implode() して文字列に変換しトリムしたものを変数 $sql に代入したものを戻します。toSql() は受け取った戻り値をそのまま戻します。
runSelect() は受け取った SQL文を使いPDOステートメントを生成しクエリを実行し fetchAll() た結果の配列を戻します。 get() メソッドは受け取った配列を引数として生成した Collection インスタンスを戻します。
aggregate() メソッドは受け取った Collection インスタンスに情報が含まれていた場合、その結果のキーを全て小文字に変換した配列の 「aggregate」 がキーの値を戻します。
max() getLastBatchNumber() と値が戻されて、getNextBatchNumber() メソッドで戻り値に 1 を加算した数が戻されます。null のケースの例外処理が抜けているような気がします。気にせず進みましょう。

Migrator::runPending() メソッドの戻り値が $batch に代入されました。
これは、最終バッチ番号をインクリメントし、次のバッチ番号を求める値ですね。

次にオプションの $pretend と $step を整えます。今回は使わなそうですね。
fireMigrationEvent() メソッドで MigrationsStarted インスタンスをディスパッチしてます。
MigrationsStarted は定義がほぼ空っぽのクラスです。イベント登録処理のためのものでしょう。

いよいよマイグレーションファイルの処理の開始ですね。
runPending() メソッドが引数として受け取ったマイグレーションファイルの配列を foreach で回します。
$this->runUp() メソッドをファイルとバッチ番号、pretend オプションを引数として渡しコールします。
ステップオプションが付いている場合は処理ごとにバッチ番号をインクリメントします。

その１８に続きます。

The post 【フレームワークを読む】Laravelのマイグレーションファイルは何をしているのか？ ：その１７：Migrator:: runPending() appeared first on XIONCC.

Illuminate\Database\Migrations\Migrator::run()

    /**
     * Run the pending migrations at a given path.
     *
     * @param  array|string  $paths
     * @param  array  $options
     * @return array
     */
    public function run($paths = [], array $options = [])
    {
        // Once we grab all of the migration files for the path, we will compare them
        // against the migrations that have already been run for this package then
        // run each of the outstanding migrations against a database connection.
        $files = $this->getMigrationFiles($paths);

        $this->requireFiles($migrations = $this->pendingMigrations(
            $files, $this->repository->getRan()
        ));

        // Once we have all these migrations that are outstanding we are ready to run
        // we will go ahead and run them "up". This will execute each migration as
        // an operation against a database. Then we'll return this list of them.
        $this->runPending($migrations, $options);

        return $migrations;
    }

getMigrationFiles() メソッドの戻り値を $files に代入するところまで読みました。
次は requireFiles() メソッドがコールされています。引数から見てみましょう。
pendingMigrations() メソッドをマイグレーションファイル配列と $this->repository->getRan() の戻り値を渡してコールした戻り値を $migrations に代入しています。

Illuminate\Database\Migrations\Migrator::pendingMigrations()

    /**
     * Get the migration files that have not yet run.
     *
     * @param  array  $files
     * @param  array  $ran
     * @return array
     */
    protected function pendingMigrations($files, $ran)
    {
        return Collection::make($files)
                ->reject(function ($file) use ($ran) {
                    return in_array($this->getMigrationName($file), $ran);
                })->values()->all();
    }

Illuminate\Database\Migrations\DatabaseMigrationRepository::getRan()

    /**
     * Get the completed migrations.
     *
     * @return array
     */
    public function getRan()
    {
        return $this->table()
                ->orderBy('batch', 'asc')
                ->orderBy('migration', 'asc')
                ->pluck('migration')->all();
    }
    /**
     * Get a query builder for the migration table.
     *
     * @return \Illuminate\Database\Query\Builder
     */
    protected function table()
    {
        return $this->getConnection()->table($this->table)->useWritePdo();
    }
    /**
     * Resolve the database connection instance.
     *
     * @return \Illuminate\Database\Connection
     */
    public function getConnection()
    {
        return $this->resolver->connection($this->connection);
    }

Illuminate\Database\ConnectionResolver::connection()

    /**
     * Get a database connection instance.
     *
     * @param  string|null  $name
     * @return \Illuminate\Database\ConnectionInterface
     */
    public function connection($name = null)
    {
        if (is_null($name)) {
            $name = $this->getDefaultConnection();
        }

        return $this->connections[$name];
    }

まず、getRan() メソッドを読みましょう。
table() メソッドは、getConnection で接続を取得し、戻り値のtable() メソッドをコールします。

Illuminate\Database\Connection::table() | 関連メソッド

    /**
     * Begin a fluent query against a database table.
     *
     * @param  \Closure|\Illuminate\Database\Query\Builder|string  $table
     * @param  string|null  $as
     * @return \Illuminate\Database\Query\Builder
     */
    public function table($table, $as = null)
    {
        return $this->query()->from($table, $as);
    }

    /**
     * Get a new query builder instance.
     *
     * @return \Illuminate\Database\Query\Builder
     */
    public function query()
    {
        return new QueryBuilder(
            $this, $this->getQueryGrammar(), $this->getPostProcessor()
        );
    }
    /**
     * Get the query grammar used by the connection.
     *
     * @return \Illuminate\Database\Query\Grammars\Grammar
     */
    public function getQueryGrammar()
    {
        return $this->queryGrammar;
    }
    /**
     * Get the query post processor used by the connection.
     *
     * @return \Illuminate\Database\Query\Processors\Processor
     */
    public function getPostProcessor()
    {
        return $this->postProcessor;
    }
    /**
     * Create a new database connection instance.
     *
     * @param  \PDO|\Closure  $pdo
     * @param  string  $database
     * @param  string  $tablePrefix
     * @param  array  $config
     * @return void
     */
    public function __construct($pdo, $database = '', $tablePrefix = '', array $config = [])
    {
        $this->pdo = $pdo;

        // First we will setup the default properties. We keep track of the DB
        // name we are connected to since it is needed when some reflective
        // type commands are run such as checking whether a table exists.
        $this->database = $database;

        $this->tablePrefix = $tablePrefix;

        $this->config = $config;

        // We need to initialize a query grammar and the query post processors
        // which are both very important parts of the database abstractions
        // so we initialize these to their default values while starting.
        $this->useDefaultQueryGrammar();

        $this->useDefaultPostProcessor();
    }
    /**
     * Set the query post processor to the default implementation.
     *
     * @return void
     */
    public function useDefaultPostProcessor()
    {
        $this->postProcessor = $this->getDefaultPostProcessor();
    }

Illuminate\Database\MySqlConnection::getDefaultPostProcessor() | 関連メソッド

    /**
     * Get the default post processor instance.
     *
     * @return \Illuminate\Database\Query\Processors\MySqlProcessor
     */
    protected function getDefaultPostProcessor()
    {
        return new MySqlProcessor;
    }

table() メソッドは query() メソッドの戻り値の from() メソッドをコールします。
from() メソッドは後で読みましょう。
query() メソッドは 自身と、 getQueryGrammar() メソッドの戻り値、今回は MySqlGrammar インスタンスと、 getPostProcessor() メソッドの戻り値、今回は MySqlProcessor インスタンスを引数に渡し QueryBuilder インスタンスを生成し戻します。
MySqlProcessor は Connection クラスのコンストラクタで useDefaultPostProcessor() メソッドがコールされ useDefaultPostProcessor() メソッドから getDefaultPostProcessor() メソッドがコールされ MySqlConnection::getDefaultPostProcessor で MySqlProcessor インスタンスが生成され戻されます。

QueryBuilder::from() メソッドを見てみましょう。

Illuminate\Database\Query\Builder::from()

    /**
     * Set the table which the query is targeting.
     *
     * @param  \Closure|\Illuminate\Database\Query\Builder|string  $table
     * @param  string|null  $as
     * @return $this
     */
    public function from($table, $as = null)
    {
        if ($this->isQueryable($table)) {
            return $this->fromSub($table, $as);
        }

        $this->from = $as ? "{$table} as {$as}" : $table;

        return $this;
    }
    /**
     * Determine if the value is a query builder instance or a Closure.
     *
     * @param  mixed  $value
     * @return bool
     */
    protected function isQueryable($value)
    {
        return $value instanceof self ||
               $value instanceof EloquentBuilder ||
               $value instanceof Closure;
    }
    /**
     * Makes "from" fetch from a subquery.
     *
     * @param  \Closure|\Illuminate\Database\Query\Builder|string  $query
     * @param  string  $as
     * @return $this
     *
     * @throws \InvalidArgumentException
     */
    public function fromSub($query, $as)
    {
        [$query, $bindings] = $this->createSub($query);

        return $this->fromRaw('('.$query.') as '.$this->grammar->wrapTable($as), $bindings);
    }
    /**
     * Add a raw from clause to the query.
     *
     * @param  string  $expression
     * @param  mixed  $bindings
     * @return $this
     */
    public function fromRaw($expression, $bindings = [])
    {
        $this->from = new Expression($expression);

        $this->addBinding($bindings, 'from');

        return $this;
    }
    /**
     * Creates a subquery and parse it.
     *
     * @param  \Closure|\Illuminate\Database\Query\Builder|string  $query
     * @return array
     */
    protected function createSub($query)
    {
        // If the given query is a Closure, we will execute it while passing in a new
        // query instance to the Closure. This will give the developer a chance to
        // format and work with the query before we cast it to a raw SQL string.
        if ($query instanceof Closure) {
            $callback = $query;

            $callback($query = $this->forSubQuery());
        }

        return $this->parseSub($query);
    }
    /**
     * Create a new query instance for a sub-query.
     *
     * @return \Illuminate\Database\Query\Builder
     */
    protected function forSubQuery()
    {
        return $this->newQuery();
    }
     /**
     * Get a new instance of the query builder.
     *
     * @return \Illuminate\Database\Query\Builder
     */
    public function newQuery()
    {
        return new static($this->connection, $this->grammar, $this->processor);
    }
    /**
     * Parse the subquery into SQL and bindings.
     *
     * @param  mixed  $query
     * @return array
     *
     * @throws \InvalidArgumentException
     */
    protected function parseSub($query)
    {
        if ($query instanceof self || $query instanceof EloquentBuilder) {
            return [$query->toSql(), $query->getBindings()];
        } elseif (is_string($query)) {
            return [$query, []];
        } else {
            throw new InvalidArgumentException(
                'A subquery must be a query builder instance, a Closure, or a string.'
            );
        }
    }

isQueryable() メソッドをコールして戻り値を検証しています。
isQueryable() は引数が、 Builder インスタンス若しくは EloquentBuilder インスタンス若しくはクロージャーであれば true そうでなければ false を戻します。
戻り値が true の場合、 fromSub() メソッドを引数をそのまま渡してコールします。
false の場合は、第二引数の $as が渡されていた場合はテーブル名にエイリアス設定を追加したSQL文を $this->from に代入し 自身を戻します。
fromSub() メソッドを読みましょう。
createSub() メソッドを第一引数を渡してコールした戻り値をクエリ文とバインド値に代入しています。
createSub() メソッドは受け取った引数がクロージャーだった場合、 forSubQuery() メソッドをコールし forSubQuery() から newQuery() をコールし Builder インスタンスを生成して戻します。
クロージャーでない場合は parseSub() メソッドに引数を渡してコールした戻り値を戻します。
parseSub() メソッドは受け取った引数が Builder インスタンス若しくは EloquentBuilder インスタンスだった場合は、 toSql() メソッドと getBuildings() メソッドの戻り値を配列にしたものを戻します。toSql() から見てみましょう。

Illuminate\Database\Query\Builder::toSql()

    /**
     * Get the SQL representation of the query.
     *
     * @return string
     */
    public function toSql()
    {
        return $this->grammar->compileSelect($this);
    }

Illuminate\Database\Query\Grammars\Grammar::compileSelect()

    /**
     * Compile a select query into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return string
     */
    public function compileSelect(Builder $query)
    {
        if ($query->unions && $query->aggregate) {
            return $this->compileUnionAggregate($query);
        }

        // If the query does not have any columns set, we'll set the columns to the
        // * character to just get all of the columns from the database. Then we
        // can build the query and concatenate all the pieces together as one.
        $original = $query->columns;

        if (is_null($query->columns)) {
            $query->columns = ['*'];
        }

        // To compile the query, we'll spin through each component of the query and
        // see if that component exists. If it does we'll just call the compiler
        // function for the component which is responsible for making the SQL.
        $sql = trim($this->concatenate(
            $this->compileComponents($query))
        );

        if ($query->unions) {
            $sql = $this->wrapUnion($sql).' '.$this->compileUnions($query);
        }

        $query->columns = $original;

        return $sql;
    }
    /**
     * Compile a union aggregate query into SQL.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return string
     */
    protected function compileUnionAggregate(Builder $query)
    {
        $sql = $this->compileAggregate($query, $query->aggregate);

        $query->aggregate = null;

        return $sql.' from ('.$this->compileSelect($query).') as '.$this->wrapTable('temp_table');
    }

Grammar インスタンスの compileSelect() メソッドに自身を引数として渡してコールしています。
$query->unions と $query->aggregate を検証しています。このパラメーターを更新するのは union() と setAggregate() です。こちらをコールした場所はありませんでしたので今回はここは通りません。
ここを通る場合は、 compileUnionAggregate() メソッドがコールされます。見てみましょう。

Illuminate\Database\Query\Grammars\Grammar::compileAggregate() | 関連メソッド

    /**
     * Compile an aggregated select clause.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $aggregate
     * @return string
     */
    protected function compileAggregate(Builder $query, $aggregate)
    {
        $column = $this->columnize($aggregate['columns']);

        // If the query has a "distinct" constraint and we're not asking for all columns
        // we need to prepend "distinct" onto the column name so that the query takes
        // it into account when it performs the aggregating operations on the data.
        if (is_array($query->distinct)) {
            $column = 'distinct '.$this->columnize($query->distinct);
        } elseif ($query->distinct && $column !== '*') {
            $column = 'distinct '.$column;
        }

        return 'select '.$aggregate['function'].'('.$column.') as aggregate';
    }
    /**
     * Convert an array of column names into a delimited string.
     *
     * @param  array  $columns
     * @return string
     */
    public function columnize(array $columns)
    {
        return implode(', ', array_map([$this, 'wrap'], $columns));
    }

columnize() メソッドを $aggregate['columns'] を引数として渡しコールします。
columnize() メソッドは array_map() で渡されたカラム配列を $this->wrap() を通し、 implode() で連結し戻します。wrap() を見てみましょう。

Illuminate\Database\Query\Grammars\Grammar::wrap()

    /**
     * Wrap a value in keyword identifiers.
     *
     * @param  \Illuminate\Database\Query\Expression|string  $value
     * @param  bool  $prefixAlias
     * @return string
     */
    public function wrap($value, $prefixAlias = false)
    {
        if ($this->isExpression($value)) {
            return $this->getValue($value);
        }

        // If the value being wrapped has a column alias we will need to separate out
        // the pieces so we can wrap each of the segments of the expression on its
        // own, and then join these both back together using the "as" connector.
        if (stripos($value, ' as ') !== false) {
            return $this->wrapAliasedValue($value, $prefixAlias);
        }

        // If the given value is a JSON selector we will wrap it differently than a
        // traditional value. We will need to split this path and wrap each part
        // wrapped, etc. Otherwise, we will simply wrap the value as a string.
        if ($this->isJsonSelector($value)) {
            return $this->wrapJsonSelector($value);
        }

        return $this->wrapSegments(explode('.', $value));
    }
    /**
     * Determine if the given value is a raw expression.
     *
     * @param  mixed  $value
     * @return bool
     */
    public function isExpression($value)
    {
        return $value instanceof Expression;
    }
    /**
     * Get the value of a raw expression.
     *
     * @param  \Illuminate\Database\Query\Expression  $expression
     * @return string
     */
    public function getValue($expression)
    {
        return $expression->getValue();
    }

Illuminate\Database\Query\Expression::getValue()

    /**
     * Get the value of the expression.
     *
     * @return mixed
     */
    public function getValue()
    {
        return $this->value;
    }
    /**
     * Wrap the given JSON selector.
     *
     * @param  string  $value
     * @return string
     *
     * @throws \RuntimeException
     */
    protected function wrapJsonSelector($value)
    {
        throw new RuntimeException('This database engine does not support JSON operations.');
    }

このメソッドは見覚えありますね。スキーマーのグラマーにも同じようなものがありました。処理も似ているのかもしれません。読んでみましょう。
isExpression() メソッドで引数を調べています。 Expression インスタンスだった場合は、getValue() メソッドに引数を渡し、getValue() メソッドで引数の getValue() メソッドをコールした戻り値を戻しています。Expression::getValue() は $this->value を返しているだけですね。
見たところ、スキーマの時の処理とほぼ同じようです。
１点違う部分は、 isJsonSelector() メソッドを検証しています。見てみましょう。

Illuminate\Database\Query\Grammars\Grammar::isJsonSelector()

    /**
     * Determine if the given string is a JSON selector.
     *
     * @param  string  $value
     * @return bool
     */
    protected function isJsonSelector($value)
    {
        return Str::contains($value, '->');
    }

Illuminate\Support\Str::contains()

    /**
     * Determine if a given string contains a given substring.
     *
     * @param  string  $haystack
     * @param  string|string[]  $needles
     * @return bool
     */
    public static function contains($haystack, $needles)
    {
        foreach ((array) $needles as $needle) {
            if ($needle !== '' && mb_strpos($haystack, $needle) !== false) {
                return true;
            }
        }

        return false;
    }

Str::contains() に引数と 「->」 を渡しています。
Str::contains() メソッドは第二引数を foreach で回し 第一引数の中にその文字列があった場合 true を、ない場合は false を返します。つまり mb_strpos() の配列対応関数ですね。

集計カラム用のSQL文が生成されました。
次は $this->distinct が配列か検証します。配列だった場合はこちらも columnize() メソッドでSQL文を生成します。
配列でない場合で且つ null でなく、整形しているSQL文が 「*」 でなかった場合は、 「distinct」文にカラム名を連結しSQL文を生成します。
出来上がったSQL文を使いセブクエリの文字列を戻します。

compileSelect() に戻りましょう。
引数として受け取った Builder インスタンスのカラムパラメータを検証し、null だった場合、「*」 を代入します。

concatenate() に引数として compileComponents() に引数として受け取った Builder インスタンスを渡してコールした戻り値を渡してコールしています。

Illuminate\Database\Query\Grammars\Grammar::compileComponents() | 関連メソッド

    /**
     * The components that make up a select clause.
     *
     * @var array
     */
    protected 
        $selectComponents = [
        'aggregate',
        'columns',
        'from',
        'joins',
        'wheres',
        'groups',
        'havings',
        'orders',
        'limit',
        'offset',
        'lock',
    ];
    /**
     * Compile the components necessary for a select clause.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return array
     */
    protected function compileComponents(Builder $query)
    {
        $sql = [];

        foreach ($this->selectComponents as $component) {
            // To compile the query, we'll spin through each component of the query and
            // see if that component exists. If it does we'll just call the compiler
            // function for the component which is responsible for making the SQL.
            if (isset($query->$component) && ! is_null($query->$component)) {
                $method = 'compile'.ucfirst($component);

                $sql[$component] = $this->$method($query, $query->$component);
            }
        }

        return $sql;
    }
    /**
     * Concatenate an array of segments, removing empties.
     *
     * @param  array  $segments
     * @return string
     */
    protected function concatenate($segments)
    {
        return implode(' ', array_filter($segments, function ($value) {
            return (string) $value !== '';
        }));
    }

compileComponents() を見てみましょう。
selectComponents をforeach で回して Builder インスタンスに $selectComponents のパラメーターが設定されていた場合、文字列 「compile」 と$selectComponents の値を結合しメソッド名を生成し、そのメソッドをコールした戻り値を SQL配列に代入したものを戻します。
concatenate() メソッドは受け取ったSQL文の配列を implode() したものを戻します。

compileSelect() の続きです。
引数として受け取った Builder インスタンスに unions のパラメータがあった場合は wrapUnion() メソッドと compileUnions() メソッドの戻り値を連結してSQL文を生成します。
見てみましょう。

Illuminate\Database\Query\Grammars\Grammar::wrapUnion()

    /**
     * Wrap a union subquery in parentheses.
     *
     * @param  string  $sql
     * @return string
     */
    protected function wrapUnion($sql)
    {
        return '('.$sql.')';
    }
    /**
     * Compile the "union" queries attached to the main query.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return string
     */
    protected function compileUnions(Builder $query)
    {
        $sql = '';

        foreach ($query->unions as $union) {
            $sql .= $this->compileUnion($union);
        }

        if (! empty($query->unionOrders)) {
            $sql .= ' '.$this->compileOrders($query, $query->unionOrders);
        }

        if (isset($query->unionLimit)) {
            $sql .= ' '.$this->compileLimit($query, $query->unionLimit);
        }

        if (isset($query->unionOffset)) {
            $sql .= ' '.$this->compileOffset($query, $query->unionOffset);
        }

        return ltrim($sql);
    }
    /**
     * Compile a single union statement.
     *
     * @param  array  $union
     * @return string
     */
    protected function compileUnion(array $union)
    {
        $conjunction = $union['all'] ? ' union all ' : ' union ';

        return $conjunction.$this->wrapUnion($union['query']->toSql());
    }
    /**
     * Compile the "order by" portions of the query.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $orders
     * @return string
     */
    protected function compileOrders(Builder $query, $orders)
    {
        if (! empty($orders)) {
            return 'order by '.implode(', ', $this->compileOrdersToArray($query, $orders));
        }

        return '';
    }
    /**
     * Compile the "limit" portions of the query.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  int  $limit
     * @return string
     */
    protected function compileLimit(Builder $query, $limit)
    {
        return 'limit '.(int) $limit;
    }
    /**
     * Compile the "offset" portions of the query.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  int  $offset
     * @return string
     */
    protected function compileOffset(Builder $query, $offset)
    {
        return 'offset '.(int) $offset;
    }

wrapUnion() メソッドは受け取ったSQL文を「()」で囲んで戻すだけです。
compileUnions() は受け取った Builder インスタンスをforeachで回し、パラメーターごとに文字列整形してSQL文を組み立てていく流れになっていますね。

こうして整えられた SQL文を compileSelect() メソッドは戻しています。

parseSub() メソッドに戻ります。
もう一つの戻り値 $query->getBindings() を見てみましょう。

Illuminate\Database\Query\Builder::getBindings()

    /**
     * Get the current query value bindings in a flattened array.
     *
     * @return array
     */
    public function getBindings()
    {
        return Arr::flatten($this->bindings);
    }

Illuminate\Support\Arr::flatten()

    /**
     * Flatten a multi-dimensional array into a single level.
     *
     * @param  iterable  $array
     * @param  int  $depth
     * @return array
     */
    public static function flatten($array, $depth = INF)
    {
        $result = [];

        foreach ($array as $item) {
            $item = $item instanceof Collection ? $item->all() : $item;

            if (! is_array($item)) {
                $result[] = $item;
            } else {
                $values = $depth === 1
                    ? array_values($item)
                    : static::flatten($item, $depth - 1);

                foreach ($values as $value) {
                    $result[] = $value;
                }
            }
        }

        return $result;
    }

Arr::flatten() メソッドを引数にバインド値を渡して静的コールしています。
Arr::flatten() は多次元配列を再帰的に一次配列に変換して返す関数ですね。

parseSub() メソッドの続きです。

受け取った引数が Builder インスタンスでも EloquentBuilder インスタンスでもなかった場合、それがストリング型か検証し、そうだった場合は引数と空の配列を配列に入れて戻します。どれでもなかった場合は「A subquery must be a query builder instance, a Closure, or a string.」 をメッセージを添えて例外 InvalidArgumentException をスローします。

parseSub() メソッドから戻されたSQL文配列を createSub() メソッドはそのまま fromSub() に戻します。fromSub() は受け取ったクエリ文を整形したものとバインド値を引数として fromRow() メソッドに渡し戻り値を戻します。
fromRaw() メソッドは 受け取ったSQL文を元に Expression インスタンスを生成し、$this->from に代入します。
次に受け取ったバインド値を引数として渡して addBinding() メソッドをコールします。
addBinding() を見てみましょう。

Illuminate\Database\Query\Builder::addBinding()

    /**
     * The current query value bindings.
     *
     * @var array
     */
    public $bindings = [
        'select' => [],
        'from' => [],
        'join' => [],
        'where' => [],
        'groupBy' => [],
        'having' => [],
        'order' => [],
        'union' => [],
        'unionOrder' => [],
    ];
    /**
     * Add a binding to the query.
     *
     * @param  mixed  $value
     * @param  string  $type
     * @return $this
     *
     * @throws \InvalidArgumentException
     */
    public function addBinding($value, $type = 'where')
    {
        if (! array_key_exists($type, $this->bindings)) {
            throw new InvalidArgumentException("Invalid binding type: {$type}.");
        }

        if (is_array($value)) {
            $this->bindings[$type] = array_values(array_merge($this->bindings[$type], $value));
        } else {
            $this->bindings[$type][] = $value;
        }

        return $this;
    }

第二引数として受けたっとタイプが $this->bindings に含まれていない場合は、「Invalid binding type: {$type}.」 とメッセージを添えて例外 InvalidArgumentException をスローします。
受け取った第一引数が配列の場合、$this->bindings[] の第二引数をキーにした値に第一引数を array_merge() したものを array_values() したものを代入します。
配列でなかった場合、$this->bindings[] の第二引数をキーにした配列に第一引数を追加します。
$this->bindings[] へ値の追加をした後自身を戻します。

addBinding() メソッドから自身を戻された fromRaw() メソッドは fromSub() に自身を戻し、fromSub() メソッドはさらにそれを戻します。

Builder::from() メソッドに戻ります。結構経ってしまったのでもう一度見てみましょう。

Illuminate\Database\Query\Builder::from()

    /**
     * Set the table which the query is targeting.
     *
     * @param  \Closure|\Illuminate\Database\Query\Builder|string  $table
     * @param  string|null  $as
     * @return $this
     */
    public function from($table, $as = null)
    {
        if ($this->isQueryable($table)) {
            return $this->fromSub($table, $as);
        }
        $this->from = $as ? "{$table} as {$as}" : $table;
        return $this;
    }
    /**
     * Determine if the value is a query builder instance or a Closure.
     *
     * @param  mixed  $value
     * @return bool
     */
    protected function isQueryable($value)
    {
        return $value instanceof self ||
               $value instanceof EloquentBuilder ||
               $value instanceof Closure;
    }

今回は第一引数として渡されている $table には $this->table 、つまり 「migrations」 が入っていました。 isQueryable() の戻り値は false ですのでここは通りません。
第二引数 $as は null ですので、$this->from には 「migrations」 が代入されます。
$this->from に適切な値が代入された後に Connection::table() に自身を戻します。
Connection::table() は受け取った戻り値をそのまま DatabaseMigrationRepository::table() メソッドに戻します。

もう一度見てみましょう。

Illuminate\Database\Migrations\DatabaseMigrationRepository::table() | 関連メソッド

    /**
     * Get the completed migrations.
     *
     * @return array
     */
    public function getRan()
    {
        return $this->table()
                ->orderBy('batch', 'asc')
                ->orderBy('migration', 'asc')
                ->pluck('migration')->all();
    }
    /**
     * Get a query builder for the migration table.
     *
     * @return \Illuminate\Database\Query\Builder
     */
    protected function table()
    {
        return $this->getConnection()->table($this->table)->useWritePdo();
    }
    /**
     * Resolve the database connection instance.
     *
     * @return \Illuminate\Database\Connection
     */
    public function getConnection()
    {
        return $this->resolver->connection($this->connection);
    }

DatabaseMigrationRepository::table() メソッドは受け取った戻り値の useWritePdo() メソッドをコールし戻り値を戻します。

Illuminate\Database\Query\Builder::useWritePdo()

    /**
     * Use the write pdo for query.
     *
     * @return $this
     */
    public function useWritePdo()
    {
        $this->useWritePdo = true;

        return $this;
    }

useWritePdo() メソッドは、 useWritePdo パラメータを true に上書きし自身を返します。
DatabaseMigrationRepository::table() メソッドは受け取った戻り値を DatabaseMigrationRepository::getRan() メソッドに戻します。
とても長かったですが、ようやく戻ってきました。戻されるのは Builder インスタンスですね。
Builder インスタンスに、 OrderBy() メソッドをコールしたあと、 pluck() して all() してます。OrderBy() を見てみましょう。

Illuminate\Database\Query\Builder::orderBy()

    /**
     * Add an "order by" clause to the query.
     *
     * @param  \Closure|\Illuminate\Database\Query\Builder|string  $column
     * @param  string  $direction
     * @return $this
     *
     * @throws \InvalidArgumentException
     */
    public function orderBy($column, $direction = 'asc')
    {
        if ($this->isQueryable($column)) {
            [$query, $bindings] = $this->createSub($column);

            $column = new Expression('('.$query.')');

            $this->addBinding($bindings, $this->unions ? 'unionOrder' : 'order');
        }

        $direction = strtolower($direction);

        if (! in_array($direction, ['asc', 'desc'], true)) {
            throw new InvalidArgumentException('Order direction must be "asc" or "desc".');
        }

        $this->{$this->unions ? 'unionOrders' : 'orders'}[] = [
            'column' => $column,
            'direction' => $direction,
        ];

        return $this;
    }

isQueryable() メソッドで検証しています。このメソッドは、引数が Builder インスタンス若しくは EloquentBuilder インスタンス若しくはクロージャーの場合は true を、そうでなければ false を戻すものでしたね。
もしその場合は、先程読んだ流れのようにサブクエリを生成する処理をします。
ソート指定をSQL文として整形します。もし、昇順降順以外の文字列が指定されていた場合は「Order direction must be "asc" or "desc".」 とメッセージを添えて例外 InvalidArgumentException をスローします。
$this->unions を検証し、true なら 「unionOrders」、false なら 「orders」 のパラメーター配列に第一引数をカラムとして、第二引数をソート順として代入し、自身を戻します。
今回は、 $this->orders[] に ['column' => 'batch', 'direction' => 'asc'], ['column' => 'migration', 'direction' => 'asc'] が追加される感じでしょう。
その後、戻された Builder インスタンスの pluck() メソッドがコールされる流れですね。

Illuminate\Database\Query\Builder::pluck() | 関連メソッド

    /**
     * Get an array with the values of a given column.
     *
     * @param  string  $column
     * @param  string|null  $key
     * @return \Illuminate\Support\Collection
     */
    public function pluck($column, $key = null)
    {
        // First, we will need to select the results of the query accounting for the
        // given columns / key. Once we have the results, we will be able to take
        // the results and get the exact data that was requested for the query.
        $queryResult = $this->onceWithColumns(
            is_null($key) ? [$column] : [$column, $key],
            function () {
                return $this->processor->processSelect(
                    $this, $this->runSelect()
                );
            }
        );

        if (empty($queryResult)) {
            return collect();
        }

        // If the columns are qualified with a table or have an alias, we cannot use
        // those directly in the "pluck" operations since the results from the DB
        // are only keyed by the column itself. We'll strip the table out here.
        $column = $this->stripTableForPluck($column);

        $key = $this->stripTableForPluck($key);

        return is_array($queryResult[0])
                    ? $this->pluckFromArrayColumn($queryResult, $column, $key)
                    : $this->pluckFromObjectColumn($queryResult, $column, $key);
    }
    /**
     * Execute the given callback while selecting the given columns.
     *
     * After running the callback, the columns are reset to the original value.
     *
     * @param  array  $columns
     * @param  callable  $callback
     * @return mixed
     */
    protected function onceWithColumns($columns, $callback)
    {
        $original = $this->columns;

        if (is_null($original)) {
            $this->columns = $columns;
        }

        $result = $callback();

        $this->columns = $original;

        return $result;
    }

まず、onceWithColumns() メソッドをコールしています。引数にはカラム名とクロージャーを渡しています。
onceWithColumns() は、自身のcolumns の値を一時的に逃してコールバックを実行します。
その後 $this->columns をもとに戻し、コールバックの結果を戻しています。

コールバックを見てみましょう。
$this->processor の processSelect() メソッドをコールしています。
$this->processor は MySqlProcessor でしたね。
引数として渡しているのは自身と $this->runSelect() です。
$this->runSelect() から見てみましょう。

Illuminate\Database\Query\Builder::runSelect()

    /**
     * Run the query as a "select" statement against the connection.
     *
     * @return array
     */
    protected function runSelect()
    {
        return $this->connection->select(
            $this->toSql(), $this->getBindings(), ! $this->useWritePdo
        );
    }

MySqlConnection::select() をコールしています。引数に $this->toSql() 、$this->getBindings() 、$this->useWritePdo を渡しています。この３つは先程読みましたね。MySqlConnection::select() を見てみましょう。

Illuminate\Database\Connection::select()

    /**
     * Run a select statement against the database.
     *
     * @param  string  $query
     * @param  array  $bindings
     * @param  bool  $useReadPdo
     * @return array
     */
    public function select($query, $bindings = [], $useReadPdo = true)
    {
        return $this->run($query, $bindings, function ($query, $bindings) use ($useReadPdo) {
            if ($this->pretending()) {
                return [];
            }

            // For select statements, we'll simply execute the query and return an array
            // of the database result set. Each element in the array will be a single
            // row from the database table, and will either be an array or objects.
            $statement = $this->prepared($this->getPdoForSelect($useReadPdo)
                              ->prepare($query));

            $this->bindValues($statement, $this->prepareBindings($bindings));

            $statement->execute();

            return $statement->fetchAll();
        });
    }

このメソッドは以前読みましたね。クエリ文とバインド値からPDOステートメントを生成して実行するコールバックを実行して処理時間を計測する処理でした。今回は 「ORDER BY」句が入っています。クエリ生成メソッドを見てみましょう。

Illuminate\Database\Query\Grammars\Grammar::compileOrders() | compileOrdersToArray()

    /**
     * Compile the "order by" portions of the query.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $orders
     * @return string
     */
    protected function compileOrders(Builder $query, $orders)
    {
        if (! empty($orders)) {
            return 'order by '.implode(', ', $this->compileOrdersToArray($query, $orders));
        }

        return '';
    }
    /**
     * Compile the query orders to an array.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $orders
     * @return array
     */
    protected function compileOrdersToArray(Builder $query, $orders)
    {
        return array_map(function ($order) {
            return $order['sql'] ?? $this->wrap($order['column']).' '.$order['direction'];
        }, $orders);
    }

渡された第二引数 $orders が設定されていた場合、compileOrdersToArray() メソッドの戻り値の配列を implode() したものを 「ORDER BY 」 と連結して戻します。
設定されていない場合は空文字を戻します。
compileOrdersToArray() は渡された第二引数に「’sql’」がキーの値があればそれを、なければカラム名とソート順を半角スペースで連結した文字列を戻します。おそらく以下のようなSQL文が出来るのでしょう。
「SELECT migration FROM migrations ORDER BY batch ASC, migration ASC」

runSelect() は出来上がったSQL文の実行結果を配列にしたものを pluck() メソッドの onceWithColumns() の第二引数のコールバックの戻り値としてコールされる関数の第二引数として戻します。

processSelect() メソッドを見てみましょう。

Illuminate\Database\Query\Builder\Processor::processSelect()

    /**
     * Process the results of a "select" query.
     *
     * @param  \Illuminate\Database\Query\Builder  $query
     * @param  array  $results
     * @return array
     */
    public function processSelect(Builder $query, $results)
    {
        return $results;
    }

単純に第二引数を戻しているだけですね。

onceWithColumns() メソッドか渡されるのは migration と 先程のSQLの結果を配列で戻すコールバックということになります。
onceWithColumns() メソッドはコールバックの結果をそのまま戻していますので、pluck() メソッド内の $queryResult には先程のSQLの実行結果配列が代入されます。

pluck() メソッドをもう一度見てみましょう。

Illuminate\Database\Query\Builder::pluck() | 関連メソッド

    public function pluck($column, $key = null)
    {
        // First, we will need to select the results of the query accounting for the
        // given columns / key. Once we have the results, we will be able to take
        // the results and get the exact data that was requested for the query.
        $queryResult = $this->onceWithColumns(
            is_null($key) ? [$column] : [$column, $key],
            function () {
                return $this->processor->processSelect(
                    $this, $this->runSelect()
                );
            }
        );
        if (empty($queryResult)) {
            return collect();
        }
        // If the columns are qualified with a table or have an alias, we cannot use
        // those directly in the "pluck" operations since the results from the DB
        // are only keyed by the column itself. We'll strip the table out here.
        $column = $this->stripTableForPluck($column);
        $key = $this->stripTableForPluck($key);
        return is_array($queryResult[0])
                    ? $this->pluckFromArrayColumn($queryResult, $column, $key)
                    : $this->pluckFromObjectColumn($queryResult, $column, $key);
    }
    /**
     * Strip off the table name or alias from a column identifier.
     *
     * @param  string  $column
     * @return string|null
     */
    protected function stripTableForPluck($column)
    {
        if (is_null($column)) {
            return $column;
        }

        $seperator = strpos(strtolower($column), ' as ') !== false ? ' as ' : '\.';

        return last(preg_split('~'.$seperator.'~i', $column));
    }

Illuminate\Support\helpers.php 抜粋

    /**
     * Get the last element from an array.
     *
     * @param  array  $array
     * @return mixed
     */
    function last($array)
    {
        return end($array);
    }

$queryResult が空の場合は情報の入っていない Collection インスタンスを生成してそのまま戻します。

空でない場合は、stripTableForPluck() メソッドをコールします。
カラムとキーをどちらとも通します。
stripTableForPluck() は引数が null の場合そのまま戻します。
null でない場合は引数に 「 as 」が含まれている場合はセパレーターとして 「 as 」に、そうでない場合は 「\.」に設定します。
引数をセパレーターで preg_split() で配列にし、最後の値を戻します。

今回の場合はカラムが「migration」、キーは null ですね。

SQLの実行結果配列の 0番目が配列ならば、pluckFromArrayColumn() メソッド、そうでなければ pluckFromObjectColumn() メソッドをコールします。

Illuminate\Database\Query\Builder::pluckFromArrayColumn() | pluckFromObjectColumn()

    /**
     * Retrieve column values from rows represented as arrays.
     *
     * @param  array  $queryResult
     * @param  string  $column
     * @param  string  $key
     * @return \Illuminate\Support\Collection
     */
    protected function pluckFromArrayColumn($queryResult, $column, $key)
    {
        $results = [];

        if (is_null($key)) {
            foreach ($queryResult as $row) {
                $results[] = $row[$column];
            }
        } else {
            foreach ($queryResult as $row) {
                $results[$row[$key]] = $row[$column];
            }
        }

        return collect($results);
    }
    /**
     * Retrieve column values from rows represented as objects.
     *
     * @param  array  $queryResult
     * @param  string  $column
     * @param  string  $key
     * @return \Illuminate\Support\Collection
     */
    protected function pluckFromObjectColumn($queryResult, $column, $key)
    {
        $results = [];

        if (is_null($key)) {
            foreach ($queryResult as $row) {
                $results[] = $row->$column;
            }
        } else {
            foreach ($queryResult as $row) {
                $results[$row->$key] = $row->$column;
            }
        }

        return collect($results);
    }

pluckFromArrayColumn() を見てみましょう。
渡されたキーが null だった場合は、foreach で回して結果配列のカラム名キーを取得します。
null でない場合は、foreach で回して結果配列の指定キーを取得します。
取得した配列を引数として渡した Collection インスタンスを生成して戻します。
ということで、 getRan() メソッドは以下のSQLが実行された結果の配列が取得されます。

SELECT migration FROM migrations ORDER BY batch ASC, migration ASC

その１７に続きます

The post 【フレームワークを読む】Laravelのマイグレーションファイルは何をしているのか？ ：その１６：Migrator::run() appeared first on XIONCC.

Illuminate\Database\Connection::statement()

    /**
     * Execute an SQL statement and return the boolean result.
     *
     * @param  string  $query
     * @param  array  $bindings
     * @return bool
     */
    public function statement($query, $bindings = [])
    {
        return $this->run($query, $bindings, function ($query, $bindings) {
            if ($this->pretending()) {
                return true;
            }

            $statement = $this->getPdo()->prepare($query);

            $this->bindValues($statement, $this->prepareBindings($bindings));

            $this->recordsHaveBeenModified();

            return $statement->execute();
        });
    }

受け取った引数にクロージャーを加えて run() メソッドをコールしています。
見てみましょう。

Illuminate\Database\Connection::run()

    /**
     * Run a SQL statement and log its execution context.
     *
     * @param  string  $query
     * @param  array  $bindings
     * @param  \Closure  $callback
     * @return mixed
     *
     * @throws \Illuminate\Database\QueryException
     */
    protected function run($query, $bindings, Closure $callback)
    {
        $this->reconnectIfMissingConnection();

        $start = microtime(true);

        // Here we will run this query. If an exception occurs we'll determine if it was
        // caused by a connection that has been lost. If that is the cause, we'll try
        // to re-establish connection and re-run the query with a fresh connection.
        try {
            $result = $this->runQueryCallback($query, $bindings, $callback);
        } catch (QueryException $e) {
            $result = $this->handleQueryException(
                $e, $query, $bindings, $callback
            );
        }

        // Once we have run the query we will calculate the time that it took to run and
        // then log the query, bindings, and execution time so we will report them on
        // the event that the developer needs them. We'll log time in milliseconds.
        $this->logQuery(
            $query, $bindings, $this->getElapsedTime($start)
        );

        return $result;
    }

reconnectIfMissingConnection() メソッドは接続が切れていた場合再接続を試みるものでしたね。
次に $start にクエリ実行前のマイクロタイムを代入しています。
そして runQueryCallback() メソッドを TRY して $result に代入しています。
渡されたクロージャーを見てみましょう。

function ($query, $bindings) {
    if ($this->pretending()) {
        return true;
    }
    $statement = $this->getPdo()->prepare($query);
    $this->bindValues($statement, $this->prepareBindings($bindings));
    $this->recordsHaveBeenModified();
    return $statement->execute();
}

Illuminate\Database\Connection::runQueryCallback()

    /**
     * Run a SQL statement.
     *
     * @param  string  $query
     * @param  array  $bindings
     * @param  \Closure  $callback
     * @return mixed
     *
     * @throws \Illuminate\Database\QueryException
     */
    protected function runQueryCallback($query, $bindings, Closure $callback)
    {
        // To execute the statement, we'll simply call the callback, which will actually
        // run the SQL against the PDO connection. Then we can calculate the time it
        // took to execute and log the query SQL, bindings and time in our memory.
        try {
            $result = $callback($query, $bindings);
        }

        // If an exception occurs when attempting to run a query, we'll format the error
        // message to include the bindings with SQL, which will make this exception a
        // lot more helpful to the developer instead of just the database's errors.
        catch (Exception $e) {
            throw new QueryException(
                $query, $this->prepareBindings($bindings), $e
            );
        }

        return $result;
    }
    /**
     * Determine if the connection is in a "dry run".
     *
     * @return bool
     */
    public function pretending()
    {
        return $this->pretending === true;
    }
    /**
     * Indicate if any records have been modified.
     *
     * @param  bool  $value
     * @return void
     */
    public function recordsHaveBeenModified($value = true)
    {
        if (! $this->recordsModified) {
            $this->recordsModified = $value;
        }
    }

渡されたクロージャーをクエリ文とバインドを渡し TRY しています。
クロージャーは pretending() メソッドをコールしています。戻り値が true ならば true を戻しています。
pretending() は $this->pretending が true かどうかをブーリアンで返しています。 $this->pretending は初期値は false で pretend() メソッドで更新します。
今回は初期値 false なので次に行きます。

getPdo() メソッドをコールした戻り値の prepare() メソッドを引数にクエリ文を渡してコールしています。
getPdo() メソッドは PDO インスタンスを戻します。MySQL用のステートメントオブジェクトが生成され $statement に代入されます。 bindValues() は以前読みましたね。今回はバインド用の配列は空ですので処理はされません。
recordsHaveBeenModified() メソッドをコールして recordsModified に true を代入します。
準備された $statement インスタンスの execute() メソッドをコールして SQL を実行し結果を戻します。

run() メソッドに戻ります。
logQuery() をクエリ文とバインド内容と getElapsedTime() にクエリ返し時間を引数に渡しコールした戻り値を引数に渡しコールします。

getElapsedTime() からみてみましょう。

Illuminate\Database\Connection::getElapsedTime()

    /**
     * Get the elapsed time since a given starting point.
     *
     * @param  int  $start
     * @return float
     */
    protected function getElapsedTime($start)
    {
        return round((microtime(true) - $start) * 1000, 2);
    }

現在時間からクエリ開始時間を引いて整形してます。クエリ実行にかかった時間を割り出してます。

次は logQuery() を見てみましょう。

Illuminate\Database\Connection::logQuery()

    /**
     * Log a query in the connection's query log.
     *
     * @param  string  $query
     * @param  array  $bindings
     * @param  float|null  $time
     * @return void
     */
    public function logQuery($query, $bindings, $time = null)
    {
        $this->event(new QueryExecuted($query, $bindings, $time, $this));

        if ($this->loggingQueries) {
            $this->queryLog[] = compact('query', 'bindings', 'time');
        }
    }

event() メソッドを QueryExecuted インスタンスを生成したものを引数として渡しコールしています。
QueryExecuted インスタンスは、SQL、実行時間、バインドした値、接続、接続名を記録するためのクラスのようです。

Illuminate\Database\Events\QueryExecuted::__construct()

    /**
     * Create a new event instance.
     *
     * @param  string  $sql
     * @param  array  $bindings
     * @param  float|null  $time
     * @param  \Illuminate\Database\Connection  $connection
     * @return void
     */
    public function __construct($sql, $bindings, $time, $connection)
    {
        $this->sql = $sql;
        $this->time = $time;
        $this->bindings = $bindings;
        $this->connection = $connection;
        $this->connectionName = $connection->getName();
    }

event() メソッドを見てみましょう。

Illuminate\Database\Connection::event()

    /**
     * Fire the given event if possible.
     *
     * @param  mixed  $event
     * @return void
     */
    protected function event($event)
    {
        if (isset($this->events)) {
            $this->events->dispatch($event);
        }
    }

logQuery() は戻りは無いので、 run() メソッドに戻ります。
run() メソッドは PDOステートメントを実行した戻り値を戻します。

statement() メソッドは run() メソッドの戻り値を戻します。
これで Blueprint::build() メソッドの処理は完了です。
長い道のりでしたが、Illuminate\Database\Migrations\DatabaseMigrationRepository::createRepository() メソッドの実行が完了しました。
コール元の Illuminate\Console\Command::handle() の続きです。

    public function handle()
    {
        $this->repository->setSource($this->input->getOption('database'));
        $this->repository->createRepository();
        $this->info('Migration table created successfully.');
    }

$this->info() メソッドを 「Migration table created successfully.」 というメッセージを引数として渡してコールしています。
これは、 Illuminate\Console\Concerns\InteractsWithIO トレイトに定義されています。見てみましょう。

Illuminate\Console\Concerns\InteractsWithIO::info() | 関連メソッド

    /**
     * Write a string as information output.
     *
     * @param  string  $string
     * @param  int|string|null  $verbosity
     * @return void
     */
    public function info($string, $verbosity = null)
    {
        $this->line($string, 'info', $verbosity);
    }
    /**
     * Write a string as standard output.
     *
     * @param  string  $string
     * @param  string|null  $style
     * @param  int|string|null  $verbosity
     * @return void
     */
    public function line($string, $style = null, $verbosity = null)
    {
        $styled = $style ? "<$style>$string" : $string;

        $this->output->writeln($styled, $this->parseVerbosity($verbosity));
    }
    /**
     * Get the verbosity level in terms of Symfony's OutputInterface level.
     *
     * @param  string|int|null  $level
     * @return int
     */
    protected function parseVerbosity($level = null)
    {
        if (isset($this->verbosityMap[$level])) {
            $level = $this->verbosityMap[$level];
        } elseif (! is_int($level)) {
            $level = $this->verbosity;
        }

        return $level;
    }

info() メソッドは受け取ったメッセージと 「info」 というスタイル定数と null を引数として渡して line() メソッドをコールします。
line() メソッドは受け取ったメッセージをスタイルを用いて装飾して、 出力の writeln() メソッドをコールしています。
第二引数で渡している parseVerbosity() メソッドですが、受け取った引数から OutputInterface の定数を返します。
writeln() メソッドは出力に受け取った文字列に改行を追加して表示するものでしたね。
コマンドラインに 「Migration table created successfully.」 と表示されます。

Illuminate/Database/Console/Migrations/MigrateCommand::prepareDatabase() メソッドの call() メソッドの処理が終わりました。続きを読みましょう。

prepareDatabase() メソッドをコールしていたのは Illuminate\Database\Console\Migrations\MigrateCommand::handle() メソッドでした。
もう一度見てみましょう。

Illuminate\Database\Console\Migrations\MigrateCommand::handle()

    /**
     * Execute the console command.
     *
     * @return int
     */
    public function handle()
    {
        if (! $this->confirmToProceed()) {
            return 1;
        }

        $this->migrator->usingConnection($this->option('database'), function () {
            $this->prepareDatabase();

            // Next, we will check to see if a path option has been defined. If it has
            // we will use the path relative to the root of this installation folder
            // so that migrations may be run for any path within the applications.
            $this->migrator->setOutput($this->output)
                    ->run($this->getMigrationPaths(), [
                        'pretend' => $this->option('pretend'),
                        'step' => $this->option('step'),
                    ]);

            // Finally, if the "seed" option has been given, we will re-run the database
            // seed task to re-populate the database, which is convenient when adding
            // a migration and a seed at the same time, as it is only this command.
            if ($this->option('seed') && ! $this->option('pretend')) {
                $this->call('db:seed', ['--force' => true]);
            }
        });

        return 0;
    }

Illuminate\Database\Migrations\Migrator::setOutput()

    /**
     * Set the output implementation that should be used by the console.
     *
     * @param  \Symfony\Component\Console\Output\OutputInterface  $output
     * @return $this
     */
    public function setOutput(OutputInterface $output)
    {
        $this->output = $output;

        return $this;
    }

$this->migrator インスタンスの setOutput() メソッドを出力を引数として渡してコールし、戻ってくる Migrator インスタンスの run() メソッドをコールします。
引数として、getMigrationPaths() の戻り値とオプション pretend step を配列にしたものを渡します。

getMigrationPaths() メソッドを見てみましょう。

Illuminate\Database\Console\Migrations\BaseCommand::getMigrationPaths()

    /**
     * Get all of the migration paths.
     *
     * @return array
     */
    protected function getMigrationPaths()
    {
        // Here, we will check to see if a path option has been defined. If it has we will
        // use the path relative to the root of the installation folder so our database
        // migrations may be run for any customized path from within the application.
        if ($this->input->hasOption('path') && $this->option('path')) {
            return collect($this->option('path'))->map(function ($path) {
                return ! $this->usingRealPath()
                                ? $this->laravel->basePath().'/'.$path
                                : $path;
            })->all();
        }

        return array_merge(
            $this->migrator->paths(), [$this->getMigrationPath()]
        );
    }

$this->input->hasOption('path') がコールされています。
これはなんでしょうか。MigrateCommand インスタンスが生成される時に、スーパークラスの Command クラスのコンストラクタで $this->signature が設定されていた場合 configureUsingFluentDefinition() メソッドがコールされます。そこで、 $this->signature が Parser::parse() メソッドを通してオプションの説明文の配列が取得されます。これを $this->getDefinition()->addOptions($options) したものを参照します。つまり、$this->input->hasOption('path') はコマンド説明を参照して 「--path」 があるか検証しています。
$this-option() メソッドは InteractsWithIO クラスで以下のように定義されています。

Illuminate\Console\Concerns\InteractsWithIO::option()

    /**
     * Get the value of a command option.
     *
     * @param  string|null  $key
     * @return string|array|bool|null
     */
    public function option($key = null)
    {
        if (is_null($key)) {
            return $this->input->getOptions();
        }

        return $this->input->getOption($key);
    }

Symfony\Component\Console\Input\Input::getOption()

    /**
     * Returns the option value for a given option name.
     *
     * @return string|string[]|bool|null The option value
     *
     * @throws InvalidArgumentException When option given doesn't exist
     */

    public function getOption(string $name)
    {
        if (!$this->definition->hasOption($name)) {
            throw new InvalidArgumentException(sprintf('The "%s" option does not exist.', $name));
        }

        return \array_key_exists($name, $this->options) ? $this->options[$name] : $this->definition->getOption($name)->getDefault();
    }

引数としてキーが渡されていなければ、getOptions() の戻り値を、渡されていれば getOption() の戻り値を戻しています。 getOption() メソッドはオプションに指定キーの値があればそれを、なければオプション定義のデフォルト値を返します。
オプション値が返された場合は、環境に合わせてパスを整形しそれを返します。
今回はここは通らず以下を戻します。

        return array_merge(
            $this->migrator->paths(), [$this->getMigrationPath()]
        );

Illuminate\Database\Migrations\Migrator::run()

    /**
     * Get all of the custom migration paths.
     *
     * @return array
     */
    public function paths()
    {
        return $this->paths;
    }

Illuminate\Database\Console\Migrations\BaseCommand::getMigrationPath()

    /**
     * Get the path to the migration directory.
     *
     * @return string
     */
    protected function getMigrationPath()
    {
        return $this->laravel->databasePath().DIRECTORY_SEPARATOR.'migrations';
    }

paths() メソッドと getMigrationPath() メソッドの戻り値を array_merge() してます。 path() メソッドは $this->paths を戻すだけのものです。 $this->paths は代入した場所はありませんでしたので空です。 getMigrationPath() はアプリケーションのデータベースディレクトリ下の 「migrations」 を戻します。今回は、 「PROJECT_ROOT/database/migrations/」 のみの配列が戻る結果となります。

run() メソッドを見てみましょう。

Illuminate\Database\Migrations\Migrator::run()

    /**
     * Run the pending migrations at a given path.
     *
     * @param  array|string  $paths
     * @param  array  $options
     * @return array
     */
    public function run($paths = [], array $options = [])
    {
        // Once we grab all of the migration files for the path, we will compare them
        // against the migrations that have already been run for this package then
        // run each of the outstanding migrations against a database connection.
        $files = $this->getMigrationFiles($paths);

        $this->requireFiles($migrations = $this->pendingMigrations(
            $files, $this->repository->getRan()
        ));

        // Once we have all these migrations that are outstanding we are ready to run
        // we will go ahead and run them "up". This will execute each migration as
        // an operation against a database. Then we'll return this list of them.
        $this->runPending($migrations, $options);

        return $migrations;
    }
    /**
     * Get all of the migration files in a given path.
     *
     * @param  string|array  $paths
     * @return array
     */
    public function getMigrationFiles($paths)
    {
        return Collection::make($paths)->flatMap(function ($path) {
            return Str::endsWith($path, '.php') ? [$path] : $this->files->glob($path.'/*_*.php');
        })->filter()->values()->keyBy(function ($file) {
            return $this->getMigrationName($file);
        })->sortBy(function ($file, $key) {
            return $key;
        })->all();
    }

Illuminate\Support\Traits\EnumeratesValues::make()

    /**
     * Create a new collection instance if the value isn't one already.
     *
     * @param  mixed  $items
     * @return static
     */
    public static function make($items = [])
    {
        return new static($items);
    }

getMigrationFiles() メソッドを第一引数として受け取ったパス情報を引数として渡しコールしています。
パスは 「PROJECT_ROOT/database/migrations/」 でした。

getMigrationFiles() メソッドは受け取った引数を Collection::make() に引数として渡しスタティックコールしてます。 Collection::make() メソッドは EnumeratesValues トレイトで定義されている、受け取った引数を渡して自身を生成し戻すメソッドです。
戻された Collection インスタンスの flatMap() メソッドをコールバックを渡しコールします。

コールバックから見てみましょう。

function ($path) {
    return Str::endsWith($path, '.php') ? [$path] : $this->files->glob($path.'/*_*.php');
}

Str::endsWith() が使われています。これは第一引数のストリング型変数の終わりの文字列が第二引数と等価だった場合 true をそうでなければ false を返すものでした。つまり、受け取ったパスが拡張子 「.php」 のファイルパスだった場合はそのパスを配列にして戻します。
そうでなかった場合、 Filesystem インスタンスの glob() メソッドを引数にパスと「/*_*.php 」 を連結した文字列を渡してコールしています。ファイル名をワイルドカードとPHP拡張子でフィルタルールを渡しています。

Illuminate\Filesystem\Filesystem::glob()

    /**
     * Find path names matching a given pattern.
     *
     * @param  string  $pattern
     * @param  int  $flags
     * @return array
     */
    public function glob($pattern, $flags = 0)
    {
        return glob($pattern, $flags);
    }

これは glob() しているだけですね。「PROJECT_ROOT/database/」 ディレクトリにあるマイグレーションコマンドで生成されたマイグレーション用のPHPファイルの一覧のパスを配列にして戻しています。
おそらく現状は、先頭にタイムスタンプが入った 「create_user_table.php」「create_failed_jobs_table.php」「create_customers_table.php」 の３ファイルが配置されていると思います。

flatMap() を見てみましょう。

Illuminate\Support\Traits\EnumeratesValues::flatMap()

    /**
     * Map a collection and flatten the result by a single level.
     *
     * @param  callable  $callback
     * @return static
     */
    public function flatMap(callable $callback)
    {
        return $this->map($callback)->collapse();
    }

Illuminate\Support\Collection::map()

    /**
     * Run a map over each of the items.
     *
     * @param  callable  $callback
     * @return static
     */
    public function map(callable $callback)
    {
        $keys = array_keys($this->items);

        $items = array_map($callback, $this->items, $keys);

        return new static(array_combine($keys, $items));
    }

引数として渡されたコールバックを自身の map() メソッドに渡して戻り値の collapse() メソッドをコールしています。
map() メソッドは $items を渡されたコールバックでフィルタリングした後、array_combine() したものを引数として生成した Collection インスタンスを戻します。

Illuminate\Support\Collection::filter() | values()

    /**
     * Run a filter over each of the items.
     *
     * @param  callable|null  $callback
     * @return static
     */
    public function filter(callable $callback = null)
    {
        if ($callback) {
            return new static(Arr::where($this->items, $callback));
        }

        return new static(array_filter($this->items));
    }
    /**
     * Reset the keys on the underlying array.
     *
     * @return static
     */
    public function values()
    {
        return new static(array_values($this->items));
    }

Illuminate\Support\Arr::where()

    /**
     * Filter the array using the given callback.
     *
     * @param  array  $array
     * @param  callable  $callback
     * @return array
     */
    public static function where($array, callable $callback)
    {
        return array_filter($array, $callback, ARRAY_FILTER_USE_BOTH);
    }

filter() メソッドは、引数にコールバックがあった場合は Arr::where() に $this->items とコールバックを渡して戻り値を引数として渡した Collection インスタンスを戻します。
Arr::where() メソッドは array_filter() を引数に ARRAY_FILTER_USE_BOTH フラグを添えてコールした戻り値を戻すだけです。
filter() メソッドに引数が渡されていなかった場合は、そのまま array_filter() で $this->items 配列の値が false のものを削除した配列を引数として渡し生成した Collection インスタンスを戻します。

values() メソッドは渡された引数を array_values に渡してコールした戻り値を引数として生成した Collection インスタンスを戻します。

keyBy() メソッドを見てみましょう。

Illuminate\Support\Collection::keyBy()

    /**
     * Key an associative array by a field or using a callback.
     *
     * @param  callable|string  $keyBy
     * @return static
     */
    public function keyBy($keyBy)
    {
        $keyBy = $this->valueRetriever($keyBy);

        $results = [];

        foreach ($this->items as $key => $item) {
            $resolvedKey = $keyBy($item, $key);

            if (is_object($resolvedKey)) {
                $resolvedKey = (string) $resolvedKey;
            }

            $results[$resolvedKey] = $item;
        }

        return new static($results);
    }

渡されているコールバックは以下でした。

function ($file) {
    return $this->getMigrationName($file);
}

getMigrationName() メソッドをコールしています。こちらも見てみましょう。

Illuminate\Database\Migrations\Migrator::getMigrationName()

    /**
     * Get the name of the migration.
     *
     * @param  string  $path
     * @return string
     */
    public function getMigrationName($path)
    {
        return str_replace('.php', '', basename($path));
    }

引数として受け取ったパスの最後にある名前の部分だけ取り出し、「.php」 を削除しています。
続きの sortBy() を引数として渡すコールバックと一緒に見てみましょう。

function ($file, $key) {
    return $key;
}

Illuminate\Support\Collection::sortBy()

    /**
     * Sort the collection using the given callback.
     *
     * @param  callable|string  $callback
     * @param  int  $options
     * @param  bool  $descending
     * @return static
     */
    public function sortBy($callback, $options = SORT_REGULAR, $descending = false)
    {
        $results = [];

        $callback = $this->valueRetriever($callback);

        // First we will loop through the items and get the comparator from a callback
        // function which we were given. Then, we will sort the returned values and
        // and grab the corresponding values for the sorted keys from this array.
        foreach ($this->items as $key => $value) {
            $results[$key] = $callback($value, $key);
        }

        $descending ? arsort($results, $options)
            : asort($results, $options);

        // Once we have sorted all of the keys in the array, we will loop through them
        // and grab the corresponding model so we can set the underlying items list
        // to the sorted version. Then we'll just return the collection instance.
        foreach (array_keys($results) as $key) {
            $results[$key] = $this->items[$key];
        }

        return new static($results);
    }

Illuminate\Support\Traits\EnumeratesValues::valueRetriever() | useAsCallable()

    /**
     * Get a value retrieving callback.
     *
     * @param  callable|string|null  $value
     * @return callable
     */
    protected function valueRetriever($value)
    {
        if ($this->useAsCallable($value)) {
            return $value;
        }

        return function ($item) use ($value) {
            return data_get($item, $value);
        };
    }
    /**
     * Determine if the given value is callable, but not a string.
     *
     * @param  mixed  $value
     * @return bool
     */
    protected function useAsCallable($value)
    {
        return ! is_string($value) && is_callable($value);
    }

sortBy() メソッドは受け取ったコールバックを valueRetriever() メソッドに渡してコールします。
valueRetriever() メソッドは渡された引数が実行可能なコールバックか検証し、問題ない場合はそのまま戻します。
実行可能なコールバックでなかった場合、 data_get() ヘルパ関数を通すクロージャーを戻します。 data_get() は以前も出てきましたね。配列やオブジェクトにドットシンタックスでアクセス出来るようにするものです。
引数として渡されたクロージャーは第二引数をそのまま戻すものでした。
$this->items を foreach で回し、キーと値が同じ配列を生成します。
生成された配列を指定のソート方法でソートします。
ソートされた配列を foreach で回し、キーに対応した $this->items の値を代入し、出来た配列を引数として生成した Collection インスタンスを戻します。
最後の all() メソッドは $this->items をそのまま戻すだけでしたね。

結果、getMigrationFiles() の戻り値は、PROJECT_ROOT/database/migrations のディレクトリにあるマイグレーションファイルを昇順に並べ替えた配列ということですね。

その１６に続きます。

The post 【フレームワークを読む】Laravelのマイグレーションファイルは何をしているのか？ ：その１５：Connection::statement() appeared first on XIONCC.

Illuminate\Database\Schema\Builder::build()

    /**
     * Execute the blueprint to build / modify the table.
     *
     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
     * @return void
     */
    protected function build(Blueprint $blueprint)
    {
        $blueprint->build($this->connection, $this->grammar);
    }

Illuminate\Database\Schema\Blueprint::build() | 関連メソッド

    /**
     * Execute the blueprint against the database.
     *
     * @param  \Illuminate\Database\Connection  $connection
     * @param  \Illuminate\Database\Schema\Grammars\Grammar  $grammar
     * @return void
     */
    public function build(Connection $connection, Grammar $grammar)
    {
        foreach ($this->toSql($connection, $grammar) as $statement) {
            $connection->statement($statement);
        }
    }
    /**
     * Get the raw SQL statements for the blueprint.
     *
     * @param  \Illuminate\Database\Connection  $connection
     * @param  \Illuminate\Database\Schema\Grammars\Grammar  $grammar
     * @return array
     */
    public function toSql(Connection $connection, Grammar $grammar)
    {
        $this->addImpliedCommands($grammar);

        $statements = [];

        // Each type of command has a corresponding compiler function on the schema
        // grammar which is used to build the necessary SQL statements to build
        // the blueprint element, so we'll just call that compilers function.
        $this->ensureCommandsAreValid($connection);

        foreach ($this->commands as $command) {
            $method = 'compile'.ucfirst($command->name);

            if (method_exists($grammar, $method) || $grammar::hasMacro($method)) {
                if (! is_null($sql = $grammar->$method($this, $command, $connection))) {
                    $statements = array_merge($statements, (array) $sql);
                }
            }
        }

        return $statements;
    }

Builder::build() メソッドは先程準備した Blueprint インスタンスを引数に受け取ります。
Blueprint::build() メソッドを MySqlConnection と MySqlGrammar インスタンスを引数に渡しコールします。
Blueprint::build() メソッドは受け取った引数２つを toSql() メソッドに渡し戻り値を foreach で回します。

toSql() メソッドは引数として受け取った MySqlGrammar インスタンスを addImpliedCommands() メソッドに渡します。

Illuminate\Database\Schema\Blueprint:: addImpliedCommands()

    /**
     * Add the commands that are implied by the blueprint's state.
     *
     * @param  \Illuminate\Database\Schema\Grammars\Grammar  $grammar
     * @return void
     */
    protected function addImpliedCommands(Grammar $grammar)
    {
        if (count($this->getAddedColumns()) > 0 && ! $this->creating()) {
            array_unshift($this->commands, $this->createCommand('add'));
        }
        if (count($this->getChangedColumns()) > 0 && ! $this->creating()) {
            array_unshift($this->commands, $this->createCommand('change'));
        }
        $this->addFluentIndexes();
        $this->addFluentCommands($grammar);
    }
    /**
     * Get the columns on the blueprint that should be added.
     *
     * @return \Illuminate\Database\Schema\ColumnDefinition[]
     */
    public function getAddedColumns()
    {
        return array_filter($this->columns, function ($column) {
            return ! $column->change;
        });
    }

Illuminate\Support\Fluent::__get() | 関連メソッド

    /**
     * Dynamically retrieve the value of an attribute.
     *
     * @param  string  $key
     * @return mixed
     */
    public function __get($key)
    {
        return $this->get($key);
    }
    /**
     * Get an attribute from the fluent instance.
     *
     * @param  string  $key
     * @param  mixed  $default
     * @return mixed
     */
    public function get($key, $default = null)
    {
        if (array_key_exists($key, $this->attributes)) {
            return $this->attributes[$key];
        }

        return value($default);
    }

addImpliedCommands() メソッドは getAddedColumns() の戻り値の配列の数を検証します。
getAddedColumns() は $this->columns 配列に含まれる ColumnDefinition インスタンスの中で、change のパラメーターがあるものを省いた配列を戻します。
ColumnDefinition クラスは Fluent クラスを継承しています。
Fluent クラスはマジックメソッド __get() が定義してあり、get() メソッドの戻り値を戻します。 get() メソッドは $this->attributes[] に引数をキーとした値があればそれを、なければデフォルト指定された値を。指定がなければ null を戻します。array_filter() はコールバックが true を戻すもののみを配列にしたものを戻しますので、$column->change が null のもののみ配列にしたものが戻ってきます。$this->columns には id migration batch が登録された ColumnDefinition が入っています。そのどれも change をセットはしていませんので、そのまま戻ってきます。

getAddedColumns() の戻り値の配列の数が 0 より大きかった場合、さらに $this->creating() メソッドを検証します。

creating() メソッドを見てみましょう。

Illuminate\Database\Schema\Blueprint:: creating()

    /**
     * Determine if the blueprint has a create command.
     *
     * @return bool
     */
    protected function creating()
    {
        return collect($this->commands)->contains(function ($command) {
            return $command->name === 'create';
        });
    }

Illuminate\Support\helpers.php 抜粋

    /**
     * Create a collection from the given value.
     *
     * @param  mixed  $value
     * @return \Illuminate\Support\Collection
     */
    function collect($value = null)
    {
        return new Collection($value);
    }

collect() ヘルパ関数を使っています。
collect() ヘルパ関数は引数として受け取った値を引数として渡して Collection インスタンスを生成し、それを戻しています。
つまり、 $this->commands を引数として渡して生成した Collection インスタンスの contains() メソッドをクロージャーを引数として渡してコールするという流れになります。
Collection クラスを見てみましょう。

Illuminate\Support\Collection 抜粋

    use EnumeratesValues, Macroable;
    /**
     * The items contained in the collection.
     *
     * @var array
     */
    protected $items = [];

    /**
     * Create a new collection.
     *
     * @param  mixed  $items
     * @return void
     */
    public function __construct($items = [])
    {
        $this->items = $this->getArrayableItems($items);
    }
    /**
     * Determine if an item exists in the collection.
     *
     * @param  mixed  $key
     * @param  mixed  $operator
     * @param  mixed  $value
     * @return bool
     */
    public function contains($key, $operator = null, $value = null)
    {
        if (func_num_args() === 1) {
            if ($this->useAsCallable($key)) {
                $placeholder = new stdClass;

                return $this->first($key, $placeholder) !== $placeholder;
            }

            return in_array($key, $this->items);
        }

        return $this->contains($this->operatorForWhere(...func_get_args()));
    }
    /**
     * Get the first item from the collection passing the given truth test.
     *
     * @param  callable|null  $callback
     * @param  mixed  $default
     * @return mixed
     */
    public function first(callable $callback = null, $default = null)
    {
        return Arr::first($this->items, $callback, $default);
    }

Illuminate\Support\Traits\EnumeratesValues::getArrayableItems

    /**
     * Results array of items from Collection or Arrayable.
     *
     * @param  mixed  $items
     * @return array
     */
    protected function getArrayableItems($items)
    {
        if (is_array($items)) {
            return $items;
        } elseif ($items instanceof Enumerable) {
            return $items->all();
        } elseif ($items instanceof Arrayable) {
            return $items->toArray();
        } elseif ($items instanceof Jsonable) {
            return json_decode($items->toJson(), true);
        } elseif ($items instanceof JsonSerializable) {
            return (array) $items->jsonSerialize();
        } elseif ($items instanceof Traversable) {
            return iterator_to_array($items);
        }

        return (array) $items;
    }
    /**
     * Determine if the given value is callable, but not a string.
     *
     * @param  mixed  $value
     * @return bool
     */
    protected function useAsCallable($value)
    {
        return ! is_string($value) && is_callable($value);
    }

Collection クラスはコンストラクタで受け取った引数を getArrayableItems() メソッドに渡した戻り値を変数 $this->items に代入しています。今回入るのは、「create 」が登録されたFluent インスタンスが入った配列です。
getArrayableItems() はトレイト EnumeratesValues に定義されています。これは前にも見たことがありますね。引数の型に合わせて適切に配列型に直し戻すメソッドでしたね。つまり、Collection::$items は配列型であることが保証されます。
では contains() メソッドを見てみましょう。

受け取った引数が１つのみでそれがコールバック関数だった場合、stdClass を生成し、first() メソッドをコールバックと stdClass を引数として渡してコールし、戻ってきたものが stdClass と等価であるか検証し、等価でなければ true そうでなければ false を戻します。
first() メソッドを見てみましょう。

Arr::first() を登録されたコマンド配列とコールバックを引数として渡してコールしています。
Arr::first() を見てみましょう。

Illuminate\Support\Arr::first()

    /**
     * Return the first element in an array passing a given truth test.
     *
     * @param  iterable  $array
     * @param  callable|null  $callback
     * @param  mixed  $default
     * @return mixed
     */
    public static function first($array, callable $callback = null, $default = null)
    {
        if (is_null($callback)) {
            if (empty($array)) {
                return value($default);
            }

            foreach ($array as $item) {
                return $item;
            }
        }

        foreach ($array as $key => $value) {
            if ($callback($value, $key)) {
                return $value;
            }
        }

        return value($default);
    }

引数として渡されたコールバックが null で、渡された配列が空ならばデフォルトを、空でなければ１番目の配列の中身を戻しています。
コールバック関数が渡されていた場合、配列を foreach で回し、 値とキーを引数にコールバックをコールした戻り値が false でなければその値を返します。
foreach が全て回されコールバックの戻り値が全て false だった場合、デフォルト値を戻します。
今回渡されたコールバックは以下でした。

return collect($this->commands)->contains(function ($command) {
    return $command->name === 'create';
});

$this->createCommand('add') は前に読みましたね。
引数にコマンド名と引数配列を受け取り、compact() で「name 」というキーにコマンド名を代入した配列と引数配列を array_marge() したものを引数として Fluent インスタンスを生成して戻すものでした。

addImpliedCommands() メソッドの次の処理を読みましょう。
最初のものと似ていますね。

if (count($this->getChangedColumns()) > 0 && ! $this->creating()) {
    array_unshift($this->commands, $this->createCommand('change'));
}

Illuminate\Database\Schema\Blueprint::getChangedColumns()

    /**
     * Get the columns on the blueprint that should be changed.
     *
     * @return \Illuminate\Database\Schema\ColumnDefinition[]
     */
    public function getChangedColumns()
    {
        return array_filter($this->columns, function ($column) {
            return (bool) $column->change;
        });
    }

getChangedColumns() メソッドは $this->columns 配列に含まれる ColumnDefinition インスタンスの中で 「change」 パラメーターがあるものが存在し、且つ「create」 パラメーターが含まれていない場合は$this->commands に $this->createCommand('change') の戻り値を先頭に加えるというものです。

addImpliedCommands() の続きです。

$this->addFluentIndexes();
$this->addFluentCommands($grammar);

addFluentIndexes() を見てみましょう。

Illuminate\Database\Schema\Blueprint::addFluentIndexes()

    /**
     * Add the index commands fluently specified on columns.
     *
     * @return void
     */
    protected function addFluentIndexes()
    {
        foreach ($this->columns as $column) {
            foreach (['primary', 'unique', 'index', 'spatialIndex'] as $index) {
                // If the index has been specified on the given column, but is simply equal
                // to "true" (boolean), no name has been specified for this index so the
                // index method can be called without a name and it will generate one.
                if ($column->{$index} === true) {
                    $this->{$index}($column->name);
                    $column->{$index} = false;

                    continue 2;
                }

                // If the index has been specified on the given column, and it has a string
                // value, we'll go ahead and call the index method and pass the name for
                // the index since the developer specified the explicit name for this.
                elseif (isset($column->{$index})) {
                    $this->{$index}($column->name, $column->{$index});
                    $column->{$index} = false;

                    continue 2;
                }
            }
        }
    }

$this->columns を foreach で回し、ColumnDefinition::$attributes に primary unique index spatialIndex が含まれているか確認し、含まれている場合、Blueprint の各インデックス名メソッドでカラム名を登録します。

Illuminate\Database\Schema\Blueprint インデックス登録メソッド

    /**
     * Specify the primary key(s) for the table.
     *
     * @param  string|array  $columns
     * @param  string|null  $name
     * @param  string|null  $algorithm
     * @return \Illuminate\Support\Fluent
     */
    public function primary($columns, $name = null, $algorithm = null)
    {
        return $this->indexCommand('primary', $columns, $name, $algorithm);
    }
    /**
     * Specify a unique index for the table.
     *
     * @param  string|array  $columns
     * @param  string|null  $name
     * @param  string|null  $algorithm
     * @return \Illuminate\Support\Fluent
     */
    public function unique($columns, $name = null, $algorithm = null)
    {
        return $this->indexCommand('unique', $columns, $name, $algorithm);
    }
    /**
     * Specify an index for the table.
     *
     * @param  string|array  $columns
     * @param  string|null  $name
     * @param  string|null  $algorithm
     * @return \Illuminate\Support\Fluent
     */
    public function index($columns, $name = null, $algorithm = null)
    {
        return $this->indexCommand('index', $columns, $name, $algorithm);
    }
    /**
     * Specify a spatial index for the table.
     *
     * @param  string|array  $columns
     * @param  string|null  $name
     * @return \Illuminate\Support\Fluent
     */
    public function spatialIndex($columns, $name = null)
    {
        return $this->indexCommand('spatialIndex', $columns, $name);
    }
    /**
     * Add a new index command to the blueprint.
     *
     * @param  string  $type
     * @param  string|array  $columns
     * @param  string  $index
     * @param  string|null  $algorithm
     * @return \Illuminate\Support\Fluent
     */
    protected function indexCommand($type, $columns, $index, $algorithm = null)
    {
        $columns = (array) $columns;

        // If no name was specified for this index, we will create one using a basic
        // convention of the table name, followed by the columns, followed by an
        // index type, such as primary or index, which makes the index unique.
        $index = $index ?: $this->createIndexName($type, $columns);

        return $this->addCommand(
            $type, compact('index', 'columns', 'algorithm')
        );
    }
    /**
     * Create a default index name for the table.
     *
     * @param  string  $type
     * @param  array  $columns
     * @return string
     */
    protected function createIndexName($type, array $columns)
    {
        $index = strtolower($this->prefix.$this->table.'_'.implode('_', $columns).'_'.$type);

        return str_replace(['-', '.'], '_', $index);
    }

addCommand() メソッドは $this->commands[] にcreateCommand() メソッドの戻り値を代入しそれを戻すものでした。戻り値は Fluent インスタンです。

続きの addFluentCommands() メソッドを見てみましょう。引数として MySqlGrammar インスタンスを渡しています。

Illuminate\Database\Schema\Blueprint::addFluentCommands()

    /**
     * Add the fluent commands specified on any columns.
     *
     * @param  \Illuminate\Database\Schema\Grammars\Grammar  $grammar
     * @return void
     */
    public function addFluentCommands(Grammar $grammar)
    {
        foreach ($this->columns as $column) {
            foreach ($grammar->getFluentCommands() as $commandName) {
                $attributeName = lcfirst($commandName);

                if (! isset($column->{$attributeName})) {
                    continue;
                }

                $value = $column->{$attributeName};

                $this->addCommand(
                    $commandName, compact('value', 'column')
                );
            }
        }
    }

Illuminate\Database\Schema\Grammars\Grammar::getFluentCommands()

    /**
     * The commands to be executed outside of create or alter command.
     *
     * @var array
     */
    protected $fluentCommands = [];
    /**
     * Get the fluent commands for the grammar.
     *
     * @return array
     */
    public function getFluentCommands()
    {
        return $this->fluentCommands;
    }

Illuminate\Database\Schema\Grammars\PostgresGrammar

    /**
     * The commands to be executed outside of create or alter command.
     *
     * @var array
     */
    protected $fluentCommands = ['Comment'];

$this->columns を foreach で回し、$grammar->getFluentCommands() で $fluentCommands[] を取得しています。これは、各データベースに合わせた Grammar クラスで設定されているようですが、設定されているのは Postgres のみです。設定されている場合はコマンドに追加します。

toSql() メソッドの続きを見ましょう。

Illuminate\Database\Schema\Blueprint::toSql()

    /**
     * Get the raw SQL statements for the blueprint.
     *
     * @param  \Illuminate\Database\Connection  $connection
     * @param  \Illuminate\Database\Schema\Grammars\Grammar  $grammar
     * @return array
     */
    public function toSql(Connection $connection, Grammar $grammar)
    {
        $this->addImpliedCommands($grammar);

        $statements = [];

        // Each type of command has a corresponding compiler function on the schema
        // grammar which is used to build the necessary SQL statements to build
        // the blueprint element, so we'll just call that compilers function.
        $this->ensureCommandsAreValid($connection);

        foreach ($this->commands as $command) {
            $method = 'compile'.ucfirst($command->name);

            if (method_exists($grammar, $method) || $grammar::hasMacro($method)) {
                if (! is_null($sql = $grammar->$method($this, $command, $connection))) {
                    $statements = array_merge($statements, (array) $sql);
                }
            }
        }

        return $statements;
    }
    /**
     * Ensure the commands on the blueprint are valid for the connection type.
     *
     * @param  \Illuminate\Database\Connection  $connection
     * @return void
     *
     * @throws \BadMethodCallException
     */
    protected function ensureCommandsAreValid(Connection $connection)
    {
        if ($connection instanceof SQLiteConnection) {
            if ($this->commandsNamed(['dropColumn', 'renameColumn'])->count() > 1) {
                throw new BadMethodCallException(
                    "SQLite doesn't support multiple calls to dropColumn / renameColumn in a single modification."
                );
            }

            if ($this->commandsNamed(['dropForeign'])->count() > 0) {
                throw new BadMethodCallException(
                    "SQLite doesn't support dropping foreign keys (you would need to re-create the table)."
                );
            }
        }
    }

$statements に空の配列を代入します。
ensureCommandsAreValid() メソッドをコールしていますが、このメソッドの中身は SQLite 接続の場合の例外処理のようです。外部キーの削除や複数のテーブルドロップ、カラム名変更が仕様上出来ないための対応のようです。

$this->commands を foreach で回します。中身はコマンド名を登録した Fluent インスタンスです。回したコマンド名からメソッド名を整形し、MySqlGrammar クラスにそのメソッドが実装されている若しくはトレイトの $macros に登録されているか検証します。
存在した場合、MySqlGrammar の指定メソッドを自身とコマンドが登録された Fluent と接続を引数として渡しコールします。
今回は 「’create’」 コマンドが登録されていますので、MySqlGrammar::compileCreate() ですね。
見てみましょう。

Illuminate\Database\Schema\Grammars\MySqlGrammar::compileCreate()

    /**
     * Compile a create table command.
     *
     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
     * @param  \Illuminate\Support\Fluent  $command
     * @param  \Illuminate\Database\Connection  $connection
     * @return string
     */
    public function compileCreate(Blueprint $blueprint, Fluent $command, Connection $connection)
    {
        $sql = $this->compileCreateTable(
            $blueprint, $command, $connection
        );

        // Once we have the primary SQL, we can add the encoding option to the SQL for
        // the table.  Then, we can check if a storage engine has been supplied for
        // the table. If so, we will add the engine declaration to the SQL query.
        $sql = $this->compileCreateEncoding(
            $sql, $connection, $blueprint
        );

        // Finally, we will append the engine configuration onto this SQL statement as
        // the final thing we do before returning this finished SQL. Once this gets
        // added the query will be ready to execute against the real connections.
        return $this->compileCreateEngine(
            $sql, $connection, $blueprint
        );
    }

compileCreateTable() をコールしています。

Illuminate\Database\Schema\Grammars\MySqlGrammar::compileCreateTable()

    /**
     * Create the main create table clause.
     *
     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
     * @param  \Illuminate\Support\Fluent  $command
     * @param  \Illuminate\Database\Connection  $connection
     * @return string
     */
    protected function compileCreateTable($blueprint, $command, $connection)
    {
        return sprintf('%s table %s (%s)',
            $blueprint->temporary ? 'create temporary' : 'create',
            $this->wrapTable($blueprint),
            implode(', ', $this->getColumns($blueprint))
        );
    }

Illuminate\Database\Schema\Grammars\Grammar::wrapTable()

    /**
     * Wrap a table in keyword identifiers.
     *
     * @param  mixed  $table
     * @return string
     */
    public function wrapTable($table)
    {
        return parent::wrapTable(
            $table instanceof Blueprint ? $table->getTable() : $table
        );
    }

Illuminate\Database\Schema\Grammars::wrapTable()

    /**
     * Wrap a table in keyword identifiers.
     *
     * @param  \Illuminate\Database\Query\Expression|string  $table
     * @return string
     */
    public function wrapTable($table)
    {
        if (! $this->isExpression($table)) {
            return $this->wrap($this->tablePrefix.$table, true);
        }

        return $this->getValue($table);
    }

Illuminate\Database\Schema\Blueprint::getTable()

    /**
     * Get the table the blueprint describes.
     *
     * @return string
     */
    public function getTable()
    {
        return $this->table;
    }
    /**
     * Determine if the given value is a raw expression.
     *
     * @param  mixed  $value
     * @return bool
     */
    public function isExpression($value)
    {
        return $value instanceof Expression;
    }

SQL文を生成します。
Blurprint::$temporary が true ならば、「create temporary」 false ならば
「create 」が入ります。一時テーブルの指定が出来るようですね。今回は使いません。

wrapTable() メソッドを引数に Blueprint インスタンスを渡しコールしています。
Illuminate\Database\Schema\Grammars\Grammar::wrapTable() メソッドは受け取った引数が Blueprint インスタンスなら、 Blueprint::getTable() の戻り値つまりテーブル名を、そうでなければ引数として渡されているストリング型のテーブル名を、そのままスーパークラスの wrapTable() メソッドに引数として渡し戻り値を戻しています。
スーパークラスの Illuminate\Database\Schema\Grammars::wrapTable() メソッドは、引数として渡されたテーブルが Expression インスタンスかどうか検証ます。
Expression インスタンスでない場合は、Grammars::wrap() メソッドをテーブルプレフィックスとテーブル名を連結したストリング、及び true を引数として渡してコールした戻り値を戻します。見てみましょう。

Illuminate\Database\Grammar::wrap()

    /**
     * Wrap a value in keyword identifiers.
     *
     * @param  \Illuminate\Database\Query\Expression|string  $value
     * @param  bool  $prefixAlias
     * @return string
     */
    public function wrap($value, $prefixAlias = false)
    {
        if ($this->isExpression($value)) {
            return $this->getValue($value);
        }

        // If the value being wrapped has a column alias we will need to separate out
        // the pieces so we can wrap each of the segments of the expression on its
        // own, and then join these both back together using the "as" connector.
        if (stripos($value, ' as ') !== false) {
            return $this->wrapAliasedValue($value, $prefixAlias);
        }

        return $this->wrapSegments(explode('.', $value));
    }
    /**
     * Get the value of a raw expression.
     *
     * @param  \Illuminate\Database\Query\Expression  $expression
     * @return string
     */
    public function getValue($expression)
    {
        return $expression->getValue();
    }

Illuminate\Database\Query\Expression::getValue()

    /**
     * Get the value of the expression.
     *
     * @return mixed
     */
    public function getValue()
    {
        return $this->value;
    }

まず重複ですが、第一引数が Expression インスタンスであった場合は、 getValue() メソッドでっ取得した値を戻します。
そうでなかった場合は、第一引数に 「 as 」が含まれるか検証します。
含まれる場合は wrapAliasedValue() メソッドをコールします。

Illuminate\Database\Grammar::wrapAliasedValue()

    /**
     * Wrap a value that has an alias.
     *
     * @param  string  $value
     * @param  bool  $prefixAlias
     * @return string
     */
    protected function wrapAliasedValue($value, $prefixAlias = false)
    {
        $segments = preg_split('/\s+as\s+/i', $value);

        // If we are wrapping a table we need to prefix the alias with the table prefix
        // as well in order to generate proper syntax. If this is a column of course
        // no prefix is necessary. The condition will be true when from wrapTable.
        if ($prefixAlias) {
            $segments[1] = $this->tablePrefix.$segments[1];
        }

        return $this->wrap($segments[0]).' as '.$this->wrapValue($segments[1]);
    }
    /**
     * Wrap a single string in keyword identifiers.
     *
     * @param  string  $value
     * @return string
     */
    protected function wrapValue($value)
    {
        if ($value !== '*') {
            return '"'.str_replace('"', '""', $value).'"';
        }

        return $value;
    }

受け取ったテーブル名を正規表現で 「 as 」で分割し配列にしたものを $segments に代入します。
プレフィックスが指定されていた場合は、$segments[] 配列の１番目の先頭にプレフィックスを連結します。
連結したものに「 as 」と wrapValue() メソッドを通した $segments[] 配列の１番目 を wrap() メソッドに渡した引数を戻します。と書いてあるのですが、ぱっと見た感じ無限ループしそうなのですが、動くんでしょうか。僕の読みが浅いのかもしれません。
今回は 「 as 」は含まれないのでここは通りません。

wrapSegments() こちらを読みましょう。

Illuminate\Database\Grammar::wrapSegments()

    /**
     * Wrap the given value segments.
     *
     * @param  array  $segments
     * @return string
     */
    protected function wrapSegments($segments)
    {
        return collect($segments)->map(function ($segment, $key) use ($segments) {
            return $key == 0 && count($segments) > 1
                            ? $this->wrapTable($segment)
                            : $this->wrapValue($segment);
        })->implode('.');
    }

テーブル名を 「. 」で explode() したものを引数として受け取ります。

collect() ヘルパ関数に受け取った引数を渡してます。受け取った引数を $items 変数に代入した Collection インスタンスを戻すものでしたね。 Collection::map() メソッドをコールしています。

Illuminate\Support\Collection::map()

    /**
     * Run a map over each of the items.
     *
     * @param  callable  $callback
     * @return static
     */
    public function map(callable $callback)
    {
        $keys = array_keys($this->items);

        $items = array_map($callback, $this->items, $keys);

        return new static(array_combine($keys, $items));
    }

$items 配列のキーを取得し配列にしたものを $keys に代入します。
引数として渡されたコールバックに $items と $keys を渡し結果を $items に代入します。
コールバックの内容は、キーが 0 つまり０番目の配列で且つ 引数として渡された $items 中身の値が配列で１より大きければ wrapTable() メソッドに $items の 0 番目を渡してコールした戻り値を、そうでなければ 引数として渡された $items の中身の値を引数としてwrapValue() に渡しコールした戻り値を戻します。
返ってきた値を array_combine() したものを引数として生成した Collection インスタンスを戻します。

map() の戻り値 Collection インスタンスの implode() メソッドを引数に「.」を渡してコールします。

Illuminate\Support\Collection::implode()

    /**
     * Concatenate values of a given key as a string.
     *
     * @param  string  $value
     * @param  string|null  $glue
     * @return string
     */
    public function implode($value, $glue = null)
    {
        $first = $this->first();

        if (is_array($first) || is_object($first)) {
            return implode($glue, $this->pluck($value)->all());
        }

        return implode($value, $this->items);
    }
    /**
     * Get the values of a given key.
     *
     * @param  string|array  $value
     * @param  string|null  $key
     * @return static
     */
    public function pluck($value, $key = null)
    {
        return new static(Arr::pluck($this->items, $value, $key));
    }

first() メソッドをコールしています。$this->items の最初の値を取得するものでしたね。
取得した値が配列、若しくはオブジェクトの場合、引数として渡された「.」 を引数として渡して pluck() メソッドをコールし、戻り値の all() メソッドの戻り値を 第二引数で連結した文字列を戻します。
そうでなければ、$this->items 配列を 「. 」で連結した文字列を戻します。
今回は、「maigrations」 というストリング型の文字列ですので、ここは通らず、wrapValue() に行きます。

Illuminate\Database\Grammar::wrapValue()

    /**
     * Wrap a single string in keyword identifiers.
     *
     * @param  string  $value
     * @return string
     */
    protected function wrapValue($value)
    {
        if ($value !== '*') {
            return '"'.str_replace('"', '""', $value).'"';
        }
        return $value;
    }

引数として受け取った文字列が 「*」 でなかった場合は整形して戻してますね。
今回の場合「"migration"」 になります。
ようやく MySqlGrammar::compileCreateTable() が戻す SQL を生成する sprintf() の２つ目の %s までわかりました。今わかっているのは 「create table “migration” (%s)」 ですね。最後の %s を読みましょう。以下となっていました。

implode(', ', $this->getColumns($blueprint))

Illuminate\Database\Schema\Grammars\Grammar::getColumns() | 関連メソッド

    /**
     * Compile the blueprint's column definitions.
     *
     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
     * @return array
     */
    protected function getColumns(Blueprint $blueprint)
    {
        $columns = [];

        foreach ($blueprint->getAddedColumns() as $column) {
            // Each of the column types have their own compiler functions which are tasked
            // with turning the column definition into its SQL format for this platform
            // used by the connection. The column's modifiers are compiled and added.
            $sql = $this->wrap($column).' '.$this->getType($column);

            $columns[] = $this->addModifiers($sql, $blueprint, $column);
        }

        return $columns;
    }
    /**
     * Get the columns on the blueprint that should be added.
     *
     * @return \Illuminate\Database\Schema\ColumnDefinition[]
     */
    public function getAddedColumns()
    {
        return array_filter($this->columns, function ($column) {
            return ! $column->change;
        });
    }
    /**
     * Get the SQL for the column data type.
     *
     * @param  \Illuminate\Support\Fluent  $column
     * @return string
     */
    protected function getType(Fluent $column)
    {
        return $this->{'type'.ucfirst($column->type)}($column);
    }

Grammar::getColumns() は引数に Blueprint インスタンスを受け取り、それの getAddedColumns() メソッドの戻り値を foreach で回します。
getAddedColumns() は受け取った Blueprint インスタンスの $columns 配列の内容から change パラメーターの存在するものを削除した配列を戻します。
つまり、 $blueprint->columns で change パラメーターの無いものを foreach します。
foreach した値を wrap() しています。先程読みましたね。ただのストリング型ですので「"」で囲まれた値が返ってきます。それに半角スペースと getType() の戻り値を連結しています。
getType() は 各 $column の type に合わせたメソッドをコールします。
今回追加されるカラムは id migration batch の３つでした。id を生成した時に使われた配列は以下です。

array(4) {
  ["type"]=> string(7) "integer"
  ["name"]=> string(2) "id"
  ["autoIncrement"]=> bool(true)
  ["unsigned"]=> bool(true)
}

TITLE

    /**
     * Create the column definition for an integer type.
     *
     * @param  \Illuminate\Support\Fluent  $column
     * @return string
     */
    protected function typeInteger(Fluent $column)
    {
        return 'int';
    }

単純にストリング型で 「int」 と返しているだけですね。
$sql に代入される文字列は 「"id" int 」 になりそうです。
その後に $columns[] 配列に $this->addModifiers() をコールした戻り値を代入します。
見てみましょう。

Illuminate\Database\Schema\Grammars\Grammar::addModifiers()

    /**
     * Add the column modifiers to the definition.
     *
     * @param  string  $sql
     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
     * @param  \Illuminate\Support\Fluent  $column
     * @return string
     */
    protected function addModifiers($sql, Blueprint $blueprint, Fluent $column)
    {
        foreach ($this->modifiers as $modifier) {
            if (method_exists($this, $method = "modify{$modifier}")) {
                $sql .= $this->{$method}($blueprint, $column);
            }
        }

        return $sql;
    }

$this->modifiers を foreach で回しています。
modifiers は各データベースの種類に合わせて Grammar クラスで定義されています。
以下は MySql のものです。

Illuminate\Database\Schema\Grammars\MySqlGrammar::$modifiers

    /**
     * The possible column modifiers.
     *
     * @var array
     */
    protected $modifiers = [
        'Unsigned', 'Charset', 'Collate', 'VirtualAs', 'StoredAs', 'Nullable',
        'Srid', 'Default', 'Increment', 'Comment', 'After', 'First',
    ];

    /**
     * Get the SQL for an unsigned column modifier.
     *
     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
     * @param  \Illuminate\Support\Fluent  $column
     * @return string|null
     */
    protected function modifyUnsigned(Blueprint $blueprint, Fluent $column)
    {
        if ($column->unsigned) {
            return ' unsigned';
        }
    }

もし、渡された $column に 「unsigned」 が含まれている場合は 「 unsigned」という文字列を戻しています。

各カラムに対して同様の処理を行ったものを代入した配列が戻され、compileCreateTable() で implode() され SQLにが生成されます。おそらく以下のような SQL になるのでしょう。

create table “migration” (
  "id" integer unsigned auto_increment primary key,
  "migration" varchar(255),
  "batch" integer
)

MySqlGrammar::compileCreateTable() の戻り値がわかりました。
MySqlGrammar::compileCreate() の続きです。
次は compileCreateEncoding() がコールされています。見てみましょう。

Illuminate\Database\Schema\Grammars\MySqlGrammar::compileCreateEncoding()

    /**
     * Append the character set specifications to a command.
     *
     * @param  string  $sql
     * @param  \Illuminate\Database\Connection  $connection
     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
     * @return string
     */
    protected function compileCreateEncoding($sql, Connection $connection, Blueprint $blueprint)
    {
        // First we will set the character set if one has been set on either the create
        // blueprint itself or on the root configuration for the connection that the
        // table is being created on. We will add these to the create table query.
        if (isset($blueprint->charset)) {
            $sql .= ' default character set '.$blueprint->charset;
        } elseif (! is_null($charset = $connection->getConfig('charset'))) {
            $sql .= ' default character set '.$charset;
        }

        // Next we will add the collation to the create table statement if one has been
        // added to either this create table blueprint or the configuration for this
        // connection that the query is targeting. We'll add it to this SQL query.
        if (isset($blueprint->collation)) {
            $sql .= " collate '{$blueprint->collation}'";
        } elseif (! is_null($collation = $connection->getConfig('collation'))) {
            $sql .= " collate '{$collation}'";
        }

        return $sql;
    }

Blueprint インスタンスに charset が登録されていればそれを、なければ設定ファイルの文字コードを使い、デフォルト文字コードを設定する SQL を追加します。

Blueprint インスタンスに collation が登録されていればそれを、なければ設定ファイルに照合順序が登録されていればそれを使い照合順序を設定する SQL を追加します。

上記２処理を施した SQL を戻します。
おそらく今回は以下のような SQL になっているでしょう。

create table “migration” (
  "id" integer unsigned auto_increment primary key,
  "migration" varchar(255),
  "batch" integer
) default character set utf8mb4 collate utf8mb4_unicode_ci

次は compileCreateEngine() です。
見てみましょう。

Illuminate\Database\Schema\Grammars\MySqlGrammar::compileCreateEngine()

    /**
     * Append the engine specifications to a command.
     *
     * @param  string  $sql
     * @param  \Illuminate\Database\Connection  $connection
     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
     * @return string
     */
    protected function compileCreateEngine($sql, Connection $connection, Blueprint $blueprint)
    {
        if (isset($blueprint->engine)) {
            return $sql.' engine = '.$blueprint->engine;
        } elseif (! is_null($engine = $connection->getConfig('engine'))) {
            return $sql.' engine = '.$engine;
        }

        return $sql;
    }

$blueprint->engine が登録されていればそれを、登録されてない場合、設定ファイルに登録されていればそれを使いストレージエンジンを設定する SQL文を追加します。今回は指定されておらず、設定ファイルにも記述がないので追加されません。

compileCreate() メソッドが戻す SQL文がわかりました。toSql() メソッドに戻りましょう。

Illuminate\Database\Schema\Blueprint::toSql()

    /**
     * Get the raw SQL statements for the blueprint.
     *
     * @param  \Illuminate\Database\Connection  $connection
     * @param  \Illuminate\Database\Schema\Grammars\Grammar  $grammar
     * @return array
     */
    public function toSql(Connection $connection, Grammar $grammar)
    {
        $this->addImpliedCommands($grammar);

        $statements = [];

        // Each type of command has a corresponding compiler function on the schema
        // grammar which is used to build the necessary SQL statements to build
        // the blueprint element, so we'll just call that compilers function.
        $this->ensureCommandsAreValid($connection);

        foreach ($this->commands as $command) {
            $method = 'compile'.ucfirst($command->name);

            if (method_exists($grammar, $method) || $grammar::hasMacro($method)) {
                if (! is_null($sql = $grammar->$method($this, $command, $connection))) {
                    $statements = array_merge($statements, (array) $sql);
                }
            }
        }

        return $statements;
    }

$this->commands を foreach で回し登録されたコマンドのSQL文を生成し配列に入れたものを戻している処理ということがわかりました。

Blueprint::build() に戻りましょう。

Illuminate\Database\Schema\Blueprint::build() | 関連メソッド

    /**
     * Execute the blueprint against the database.
     *
     * @param  \Illuminate\Database\Connection  $connection
     * @param  \Illuminate\Database\Schema\Grammars\Grammar  $grammar
     * @return void
     */
    public function build(Connection $connection, Grammar $grammar)
    {
        foreach ($this->toSql($connection, $grammar) as $statement) {
            $connection->statement($statement);
        }
    }

その１５に続きます。

The post 【フレームワークを読む】Laravelのマイグレーションファイルは何をしているのか？ ：その１４：Builder::build() appeared first on XIONCC.

Illuminate\Database\Console\Migrations\MigrateCommand::handle()

    /**
     * Execute the console command.
     *
     * @return int
     */
    public function handle()
    {
        if (! $this->confirmToProceed()) {
            return 1;
        }

        $this->migrator->usingConnection($this->option('database'), function () {
            $this->prepareDatabase();

            // Next, we will check to see if a path option has been defined. If it has
            // we will use the path relative to the root of this installation folder
            // so that migrations may be run for any path within the applications.
            $this->migrator->setOutput($this->output)
                    ->run($this->getMigrationPaths(), [
                        'pretend' => $this->option('pretend'),
                        'step' => $this->option('step'),
                    ]);

            // Finally, if the "seed" option has been given, we will re-run the database
            // seed task to re-populate the database, which is convenient when adding
            // a migration and a seed at the same time, as it is only this command.
            if ($this->option('seed') && ! $this->option('pretend')) {
                $this->call('db:seed', ['--force' => true]);
            }
        });

        return 0;
    }
    /**
     * Resolve the database connection instance.
     *
     * @return \Illuminate\Database\Connection
     */
    public function getConnection()
    {
        return $this->resolver->connection($this->connection);
    }

まず、$this->confirmToProceed() メソッドがコールされています。
これは、Illuminate\Console\ConfirmableTrait トレイトに定義されています。
見てみましょう。

Illuminate\Console\ConfirmableTrait::confirmToProceed()

    /**
     * Confirm before proceeding with the action.
     *
     * This method only asks for confirmation in production.
     *
     * @param  string  $warning
     * @param  \Closure|bool|null  $callback
     * @return bool
     */
    public function confirmToProceed($warning = 'Application In Production!', $callback = null)
    {
        $callback = is_null($callback) ? $this->getDefaultConfirmCallback() : $callback;

        $shouldConfirm = value($callback);

        if ($shouldConfirm) {
            if ($this->hasOption('force') && $this->option('force')) {
                return true;
            }

            $this->alert($warning);

            $confirmed = $this->confirm('Do you really wish to run this command?');

            if (! $confirmed) {
                $this->comment('Command Canceled!');

                return false;
            }
        }

        return true;
    }
    /**
     * Get the default confirmation callback.
     *
     * @return \Closure
     */
    protected function getDefaultConfirmCallback()
    {
        return function () {
            return $this->getLaravel()->environment() === 'production';
        };
    }

引数として渡されたコールバック関数が null だった場合、デフォルトのコールバック関数をセットします。
value() メソッドは Laravel のヘルパ関数です。引数がクロージャならばそれの戻り値、そうでなければそのままを戻します。
今回はコールバックは指定されていないのでデフォルトコールバックが入っています。内容は コマンドアプリケーションコンテナが production であるかの検証がブーリアンで返されるものですね。現在 APP_ENV は production に設定されているので true です。
value($callback) が true だった場合、オプションに force 指定があるか検証します。もし、あった場合は true を戻します。
つまりコマンド実行確認のメソッドですね。
キャンセルされた場合は false 実行承認した場合は true が戻されます。

handle() メソッドの続きに戻ります。
$this->confirmToProceed() でキャンセルされた場合は 整数 1 を戻します。
キャンセルされなかった場合は以下が実行されます。
今回の記事の主題ですね。

Illuminate\Database\Console\Migrations\MigrateCommand::handle() 抜粋

        $this->migrator->usingConnection($this->option('database'), function () {
            $this->prepareDatabase();
            // Next, we will check to see if a path option has been defined. If it has
            // we will use the path relative to the root of this installation folder
            // so that migrations may be run for any path within the applications.
            $this->migrator->setOutput($this->output)
                    ->run($this->getMigrationPaths(), [
                        'pretend' => $this->option('pretend'),
                        'step' => $this->option('step'),
                    ]);
            // Finally, if the "seed" option has been given, we will re-run the database
            // seed task to re-populate the database, which is convenient when adding
            // a migration and a seed at the same time, as it is only this command.
            if ($this->option('seed') && ! $this->option('pretend')) {
                $this->call('db:seed', ['--force' => true]);
            }
        });

$this->migrator は Illuminate\Database\MigrationServiceProvider::registerMigrator() で以下のようにコマンドアプリケーションコンテナにシングルトン結合したものを、 Illuminate\Database\MigrationServiceProvider::registerMigrateCommand() で引数として渡して MigrateCommand インスタンスを生成し、コンストラクタで $migrator に代入したものです。

Illuminate\Database\MigrationServiceProvider::registerMigrator() | registerMigrateCommand()

    /**
     * Register the migrator service.
     *
     * @return void
     */
    protected function registerMigrator()
    {
        // The migrator is responsible for actually running and rollback the migration
        // files in the application. We'll pass in our database connection resolver
        // so the migrator can resolve any of these connections when it needs to.
        $this->app->singleton('migrator', function ($app) {
            $repository = $app['migration.repository'];

            return new Migrator($repository, $app['db'], $app['files'], $app['events']);
        });
    }
    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerMigrateCommand()
    {
        $this->app->singleton('command.migrate', function ($app) {
            return new MigrateCommand($app['migrator']);
        });
    }

Illuminate\Database\Console\Migrations\MigrateCommand::__construct() | registerMigrateCommand()

    /**
     * Create a new migration command instance.
     *
     * @param  \Illuminate\Database\Migrations\Migrator  $migrator
     * @return void
     */
    public function __construct(Migrator $migrator)
    {
        parent::__construct();

        $this->migrator = $migrator;
    }

Illuminate\Database\Migrations\Migrator を見てみましょう。

Illuminate\Database\Migrations\Migrator::__construct()

    /**
     * Create a new migrator instance.
     *
     * @param  \Illuminate\Database\Migrations\MigrationRepositoryInterface  $repository
     * @param  \Illuminate\Database\ConnectionResolverInterface  $resolver
     * @param  \Illuminate\Filesystem\Filesystem  $files
     * @param  \Illuminate\Contracts\Events\Dispatcher|null  $dispatcher
     * @return void
     */
    public function __construct(MigrationRepositoryInterface $repository,
                                Resolver $resolver,
                                Filesystem $files,
                                Dispatcher $dispatcher = null)
    {
        $this->files = $files;
        $this->events = $dispatcher;
        $this->resolver = $resolver;
        $this->repository = $repository;
    }

Illuminate\Database\Migrations\Migrator::usingConnection()

    /**
     * Execute the given callback using the given connection as the default connection.
     *
     * @param  string  $name
     * @param  callable  $callback
     * @return mixed
     */
    public function usingConnection($name, callable $callback)
    {
        $previousConnection = $this->resolver->getDefaultConnection();

        $this->setConnection($name);

        return tap($callback(), function () use ($previousConnection) {
            $this->setConnection($previousConnection);
        });
    }

$this->resolver には $app['db'] が代入されています。エイリアス設定されていて、中身は Illuminate\Database\DatabaseManager でした。DatabaseManager::getDefaultConnection() の内容は以下です。

    /**
     * Get the default connection name.
     *
     * @return string
     */
    public function getDefaultConnection()
    {
        return $this->app['config']['database.default'];
    }

    /**
     * Get the value of a command option.
     *
     * @param  string|null  $key
     * @return string|array|bool|null
     */
    public function option($key = null)
    {
        if (is_null($key)) {
            return $this->input->getOptions();
        }

        return $this->input->getOption($key);
    }

Illuminate\Database\Migrations\Migrator::setConnection()

    /**
     * Set the default connection name.
     *
     * @param  string  $name
     * @return void
     */
    public function setConnection($name)
    {
        if (! is_null($name)) {
            $this->resolver->setDefaultConnection($name);
        }

        $this->repository->setSource($name);

        $this->connection = $name;
    }

$name が null でなければ $this->resolver->setDefaultConnection() メソッドをコールしています。
resolver は DatabaseManager インスタンスでした。 setDefaultConnection()は以下です。

    /**
     * Set the default connection name.
     *
     * @param  string  $name
     * @return void
     */
    public function setDefaultConnection($name)
    {
        $this->app['config']['database.default'] = $name;
    }

$this->repository->setSource()
$this->repository は Illuminate\Database\Migrations\DatabaseMigrationRepository インスタンスです。setSource() は引数を変数に代入しているだけです。

    /**
     * Set the information source to gather data.
     *
     * @param  string  $name
     * @return void
     */
    public function setSource($name)
    {
        $this->connection = $name;
    }

usingConnection() の続きです。

return tap($callback(), function () use ($previousConnection) {
    $this->setConnection($previousConnection);
});

tap() メソッドをコールしています。これは Laravelのヘルパ関数です。

    /**
     * Call the given Closure with the given value then return the value.
     *
     * @param  mixed  $value
     * @param  callable|null  $callback
     * @return mixed
     */
    function tap($value, $callback = null)
    {
        if (is_null($callback)) {
            return new HigherOrderTapProxy($value);
        }

        $callback($value);

        return $value;
    }

では Migrations\MigrateCommand() の続きに戻りましょう。
usingConnection() の第二引数にクロージャーが渡されています。見てみましょう。

Illuminate\Database\Console\Migrations\MigrateCommand::handle() 抜粋

function () {
    $this->prepareDatabase();
    // Next, we will check to see if a path option has been defined. If it has
    // we will use the path relative to the root of this installation folder
    // so that migrations may be run for any path within the applications.
    $this->migrator->setOutput($this->output)
        ->run($this->getMigrationPaths(), [
            'pretend' => $this->option('pretend'),
            'step' => $this->option('step'),
        ]);
    // Finally, if the "seed" option has been given, we will re-run the database
    // seed task to re-populate the database, which is convenient when adding
    // a migration and a seed at the same time, as it is only this command.
    if ($this->option('seed') && ! $this->option('pretend')) {
        $this->call('db:seed', ['--force' => true]);
    }
}

Illuminate\Database\Console\Migrations\MigrateCommand::prepareDatabase()

    /**
     * Prepare the migration database for running.
     *
     * @return void
     */
    protected function prepareDatabase()
    {
        if (! $this->migrator->repositoryExists()) {
            $this->call('migrate:install', array_filter([
                '--database' => $this->option('database'),
            ]));
        }
    }

Illuminate\Database\Console\Migrations\Migrator::repositoryExists()

    /**
     * Determine if the migration repository exists.
     *
     * @return bool
     */
    public function repositoryExists()
    {
        return $this->repository->repositoryExists();
    }

Illuminate\Database\Console\Migrations\DatabaseMigrationRepository::repositoryExists()

    /**
     * Determine if the migration repository exists.
     *
     * @return bool
     */
    public function repositoryExists()
    {
        $schema = $this->getConnection()->getSchemaBuilder();

        return $schema->hasTable($this->table);
    }

Illuminate\Database\Console\Migrations\DatabaseMigrationRepository::getConnections()

    /**
     * Resolve the database connection instance.
     *
     * @return \Illuminate\Database\Connection
     */
    public function getConnection()
    {
        return $this->resolver->connection($this->connection);
    }

Illuminate\Database\DatabaseManager::connection()

    /**
     * Get a database connection instance.
     *
     * @param  string|null  $name
     * @return \Illuminate\Database\Connection
     */
    public function connection($name = null)
    {
        [$database, $type] = $this->parseConnectionName($name);

        $name = $name ?: $database;

        // If we haven't created this connection, we'll create it based on the config
        // provided in the application. Once we've created the connections we will
        // set the "fetch mode" for PDO which determines the query return types.
        if (! isset($this->connections[$name])) {
            $this->connections[$name] = $this->configure(
                $this->makeConnection($database), $type
            );
        }

        return $this->connections[$name];
    }

Illuminate\Database\MySqlConnection::getSchemaBuilder()

    /**
     * Get a schema builder instance for the connection.
     *
     * @return \Illuminate\Database\Schema\MySqlBuilder
     */
    public function getSchemaBuilder()
    {
        if (is_null($this->schemaGrammar)) {
            $this->useDefaultSchemaGrammar();
        }

        return new MySqlBuilder($this);
    }

Illuminate\Database\Schema\Builder::getSchemaBuilder()

    /**
     * Create a new database Schema manager.
     *
     * @param  \Illuminate\Database\Connection  $connection
     * @return void
     */
    public function __construct(Connection $connection)
    {
        $this->connection = $connection;
        $this->grammar = $connection->getSchemaGrammar();
    }

$this->prepareDatabase() メソッドがコールされています。
$this->prepareDatabase() メソッドでは $this->migrator->repositoryExists() の戻り値を判定しています。
$this->migrator->repositoryExists() メソッドは $this->repository->repositoryExists() の戻り値を戻しています。$this->repository->repositoryExists() は $this->getConnection()->getSchemaBuilder() の戻り値を変数 $schema に代入しています。

getConnection() は resolver つまり DatabaseManager の connection() に接続名を渡し Connection インスタンスを受け取ります。
今回はデータベースが MySQL ですので、MySqlConnection::getSchemaBuilder() をコールします。
getSchemaBuilder() は $this->schemaGrammar が null ならば、useDefaultSchemaGrammar() メソッドでスキーマグラマーをデフォルトにセットします。
SchemaBuilder インスタンスを自身を引数に渡し生成したものを返します。
SchemaBuilder インスタンスは生成時にコンストラクタで接続とグラマーを変数に代入ます。

随分とたらい回しをしました。スキーマが生成されたのを DatabaseMigrationRepository::repositoryExists() が変数に代入し、hasTable() メソッドを $this->table を引数に渡しコールします。

$this->table とは何でしょうか。この$this は DatabaseMigrationRepository インスタンスです。生成されたタイミングは Illuminate\Database\MigrationServiceProvider::registerRepository() です。見てみましょう。

Illuminate\Database\MigrationServiceProvider::registerRepository()

    /**
     * Register the migration repository service.
     *
     * @return void
     */
    protected function registerRepository()
    {
        $this->app->singleton('migration.repository', function ($app) {
            $table = $app['config']['database.migrations'];

            return new DatabaseMigrationRepository($app['db'], $table);
        });
    }

Illuminate\Database\Migrations\DatabaseMigrationRepository::__construct()

    /**
     * Create a new database migration repository instance.
     *
     * @param  \Illuminate\Database\ConnectionResolverInterface  $resolver
     * @param  string  $table
     * @return void
     */
    public function __construct(Resolver $resolver, $table)
    {
        $this->table = $table;
        $this->resolver = $resolver;
    }

次は以下が実行されます。

return $schema->hasTable($this->table);

Builder インスタンスの hasTable() がコールされています。

Illuminate\Database\Schema\MySqlBuilder::hasTable()

    /**
     * Determine if the given table exists.
     *
     * @param  string  $table
     * @return bool
     */
    public function hasTable($table)
    {
        $table = $this->connection->getTablePrefix().$table;

        return count($this->connection->select(
            $this->grammar->compileTableExists(), [$this->connection->getDatabaseName(), $table]
        )) > 0;
    }

テーブルプレフィックスを取得して対象テーブル名に連結し $table に代入します。
テーブルプレフィックスはおそらくこれを切り替えることで環境を簡単に変更できるというものでしょう。

select() メソッドをコールしています。引数を見てみましょう。

$this->grammar->compileTableExists()

$this は ConnectionFactory::createConnection() で $driver を switch で検証して生成された MySqlConnection でした。
ということで、 MySqlConnection::compileTableExists() を見てみましょう。

Illuminate\Database\MySqlConnection::getDefaultSchemaGrammar() | 関連事項

use Illuminate\Database\Schema\Grammars\MySqlGrammar as SchemaGrammar;
class MySqlConnection extends Connection
{
    /**
     * Get the default schema grammar instance.
     *
     * @return \Illuminate\Database\Schema\Grammars\MySqlGrammar
     */
    protected function getDefaultSchemaGrammar()
    {
        return $this->withTablePrefix(new SchemaGrammar);
    }

Illuminate\Database\Connection::withTablePrefix()

    /**
     * Set the table prefix and return the grammar.
     *
     * @param  \Illuminate\Database\Grammar  $grammar
     * @return \Illuminate\Database\Grammar
     */
    public function withTablePrefix(Grammar $grammar)
    {
        $grammar->setTablePrefix($this->tablePrefix);

        return $grammar;
    }

Illuminate\Database\Grammarb::setTablePrefix()

    /**
     * Set the grammar's table prefix.
     *
     * @param  string  $prefix
     * @return $this
     */
    public function setTablePrefix($prefix)
    {
        $this->tablePrefix = $prefix;

        return $this;
    }

Illuminate\Database\Schema\Grammars\MySqlGrammar::compileTableExists()

    /**
     * Compile the query to determine the list of tables.
     *
     * @return string
     */
    public function compileTableExists()
    {
        return "select * from information_schema.tables where table_schema = ? and table_name = ? and table_type = 'BASE TABLE'";
    }

MySqlConnection クラスは名前空間のエイリアス設定で SchemaGrammar を Illuminate\Database\Schema\Grammars\MySqlGrammar としています。
getDefaultSchemaGrammar() メソッドで MySqlGrammar を生成し、setTablePrefix() でテーブルプレフィックスを設定しています。

先程取得しようとしていたクエリは、 MySqlGrammar::compileTableExists() の戻り値となります。
以下がそのクエリです。

select * from information_schema.tables where table_schema = ? and table_name = ? and table_type = 'BASE TABLE'

やっとSQLが見れましたね。
このSQLを第一引数、データベース名、テーブル名を配列にしたものを第二引数として渡して select() メソッドとコールします。

Illuminate\Database\Connection::select()

    /**
     * Run a select statement against the database.
     *
     * @param  string  $query
     * @param  array  $bindings
     * @param  bool  $useReadPdo
     * @return array
     */
    public function select($query, $bindings = [], $useReadPdo = true)
    {
        return $this->run($query, $bindings, function ($query, $bindings) use ($useReadPdo) {
            if ($this->pretending()) {
                return [];
            }

            // For select statements, we'll simply execute the query and return an array
            // of the database result set. Each element in the array will be a single
            // row from the database table, and will either be an array or objects.
            $statement = $this->prepared($this->getPdoForSelect($useReadPdo)
                              ->prepare($query));

            $this->bindValues($statement, $this->prepareBindings($bindings));

            $statement->execute();

            return $statement->fetchAll();
        });
    }

run() メソッドをクエリとバインド配列とクロージャーを渡してコールしています。
クロージャーを読んでみましょう。
引数にクエリとバインド配列を受け取ります。
pretending() メソッドをコールしています。これは単に $this->pretending を見ているだけです。このパラメーターはドライランの時に true にセットすることでクエリ実行をブロックする仕様のようです。
pretending() メソッドの戻り値が true だった場合、空の配列を戻します。

続きを読みます。

$statement = $this->prepared($this->getPdoForSelect($useReadPdo)
        ->prepare($query));

Illuminate\Database\getPdoForSelect | 関連メソッド

    /**
     * Get the PDO connection to use for a select query.
     *
     * @param  bool  $useReadPdo
     * @return \PDO
     */
    protected function getPdoForSelect($useReadPdo = true)
    {
        return $useReadPdo ? $this->getReadPdo() : $this->getPdo();
    }
    /**
     * Get the current PDO connection.
     *
     * @return \PDO
     */
    public function getPdo()
    {
        if ($this->pdo instanceof Closure) {
            return $this->pdo = call_user_func($this->pdo);
        }

        return $this->pdo;
    }
    /**
     * Get the current PDO connection used for reading.
     *
     * @return \PDO
     */
    public function getReadPdo()
    {
        if ($this->transactions > 0) {
            return $this->getPdo();
        }

        if ($this->recordsModified && $this->getConfig('sticky')) {
            return $this->getPdo();
        }

        if ($this->readPdo instanceof Closure) {
            return $this->readPdo = call_user_func($this->readPdo);
        }

        return $this->readPdo ?: $this->getPdo();
    }

getPdoForSelect() メソッドが受け取る引数は読み取り専用接続を使うかどうかのブーリアンのようです。以前データベース接続のコードを読んだ際に、通常の接続 $this->pdo と 読み取り専用接続 $this->readPdo に分けるロジックがありましたね。それの切り替えを行っています。検証した適切な PDO インスタンスが戻されます。

戻された PDO インスタンスに prepare() メソッドがコールされ PDOStatement が戻されます。
戻された PDOStatement を引数にして prepared() メソッドをコールします。

Illuminate\Database\Connection::prepared()

    /**
     * Configure the PDO prepared statement.
     *
     * @param  \PDOStatement  $statement
     * @return \PDOStatement
     */
    protected function prepared(PDOStatement $statement)
    {
        $statement->setFetchMode($this->fetchMode);

        $this->event(new StatementPrepared(
            $this, $statement
        ));

        return $statement;
    }

Illuminate\Database\Events\StatementPrepared 抜粋

namespace Illuminate\Database\Events;
class StatementPrepared
{
    public $connection;
    public $statement;
    public function __construct($connection, $statement)
    {
        $this->statement = $statement;
        $this->connection = $connection;
    }
}

setFetchMode() でフェッチモードをセットします。
StatementPrepared インスタンスを Connection と PDOStatement を引数に渡し生成します。 StatementPrepared は Connection と PDOStatement を記憶しておくだけのシンプルなクラスです。
生成した StatementPrepared をイベントにディスパッチします。
PDOStatement を戻します。

select() の続きです。

$this->bindValues($statement, $this->prepareBindings($bindings));

prepareBindings() を見てみましょう。

Illuminate\Database\Connection::prepareBindings()

    /**
     * Prepare the query bindings for execution.
     *
     * @param  array  $bindings
     * @return array
     */
    public function prepareBindings(array $bindings)
    {
        $grammar = $this->getQueryGrammar();

        foreach ($bindings as $key => $value) {
            // We need to transform all instances of DateTimeInterface into the actual
            // date string. Each query grammar maintains its own date string format
            // so we'll just ask the grammar for the format to get from the date.
            if ($value instanceof DateTimeInterface) {
                $bindings[$key] = $value->format($grammar->getDateFormat());
            } elseif (is_bool($value)) {
                $bindings[$key] = (int) $value;
            }
        }

        return $bindings;
    }

バインドする値が DateTimeInterface インスタンスである場合、データベースの種類に合わせたフォーマットに変更します。
バインドする値がブーリアンの場合は整数型に変換します。

bindValues() を見てみましょう。

Illuminate\Database\Connection::bindValues()

    /**
     * Bind values to their parameters in the given statement.
     *
     * @param  \PDOStatement  $statement
     * @param  array  $bindings
     * @return void
     */
    public function bindValues($statement, $bindings)
    {
        foreach ($bindings as $key => $value) {
            $statement->bindValue(
                is_string($key) ? $key : $key + 1, $value,
                is_int($value) ? PDO::PARAM_INT : PDO::PARAM_STR
            );
        }
    }

PDOStatement とバインドする配列を受け取り、 foreach でバインドする配列を回してバインド処理していきます。ストリング型と整数型で処理を変えていますね。
PDOStatement をもう一度見てみましょう。

select * from information_schema.tables where table_schema = ? and table_name = ? and table_type = 'BASE TABLE'

このクエリに配列 [データベース名, テーブル名] がバインドされます。完成形のSQLが見れましたね。

slect() の続きです。

$statement->execute();
return $statement->fetchAll();

return count($this->connection->select(
            $this->grammar->compileTableExists(), [$this->connection->getDatabaseName(), $table]
        )) > 0;

    protected function prepareDatabase()
    {
        if (! $this->migrator->repositoryExists()) {
            $this->call('migrate:install', array_filter([
                '--database' => $this->option('database'),
            ]));
        }
    }

「’migarate’」 テーブルが存在しなかった場合、call() メソッドがコールされます。

Illuminate\Console\Concerns\CallsCommands::call()

    /**
     * Call another console command.
     *
     * @param  \Symfony\Component\Console\Command\Command|string  $command
     * @param  array  $arguments
     * @return int
     */
    public function call($command, array $arguments = [])
    {
        return $this->runCommand($command, $arguments, $this->output);
    }

Illuminate\Console\Concerns\CallsCommands::runCommand()

    /**
     * Run the given the console command.
     *
     * @param  \Symfony\Component\Console\Command\Command|string  $command
     * @param  array  $arguments
     * @param  \Symfony\Component\Console\Output\OutputInterface  $output
     * @return int
     */
    protected function runCommand($command, array $arguments, OutputInterface $output)
    {
        $arguments['command'] = $command;

        return $this->resolveCommand($command)->run(
            $this->createInputFromArguments($arguments), $output
        );
    }

call() メソッドに受け取ったコマンドとオプションにデータベースキーの情報があればそれを、なければ空の配列を引数に渡します。
call() メソッドは受け取った引数に出力を足して runCommand() メソッドに渡します。
runCommand() メソッドは resolveCommand() メソッドを引数にコマンドを渡しコールし、その戻り値のrun() メソッドをコールします。
resolveCommand() メソッドを見てみましょう。

Illuminate\Console\Concerns\CallsCommands:: resolveCommand()

    /**
     * Resolve the console command instance for the given command.
     *
     * @param  \Symfony\Component\Console\Command\Command|string  $command
     * @return \Symfony\Component\Console\Command\Command
     */
    protected function resolveCommand($command)
    {
        if (! class_exists($command)) {
            return $this->getApplication()->find($command);
        }

        $command = $this->laravel->make($command);

        if ($command instanceof SymfonyCommand) {
            $command->setApplication($this->getApplication());
        }

        if ($command instanceof self) {
            $command->setLaravel($this->getLaravel());
        }

        return $command;
    }

Symfony\Component\Console\Command::getApplication()

    /**
     * Gets the application instance for this command.
     *
     * @return Application|null An Application instance
     */
    public function getApplication()
    {
        return $this->application;
    }

resolveCommand() は受け取った引数を class_exists() で判定してクラス定義されていなければ getApplication()->find() を戻します。
getApplication() はアプリケーションインスタンスを戻します。返されたインスタンスの find() メソッドをコールします。以前、find() メソッドは読みましたね。渡されるコマンドは 「migrate:install」です。find() メソッドは、Illuminate\Database\MigrationServiceProvider::$commands から対象のコマンドがあるか検索します。

Illuminate\Database\MigrationServiceProvider::$commands | 関連メソッド

    protected $commands = [
        'Migrate' => 'command.migrate',
        'MigrateFresh' => 'command.migrate.fresh',
        'MigrateInstall' => 'command.migrate.install',
        'MigrateRefresh' => 'command.migrate.refresh',
        'MigrateReset' => 'command.migrate.reset',
        'MigrateRollback' => 'command.migrate.rollback',
        'MigrateStatus' => 'command.migrate.status',
        'MigrateMake' => 'command.migrate.make',
    ];
    /**
     * Register the migration repository service.
     *
     * @return void
     */
    protected function registerRepository()
    {
        $this->app->singleton('migration.repository', function ($app) {
            $table = $app['config']['database.migrations'];

            return new DatabaseMigrationRepository($app['db'], $table);
        });
    }
    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerMigrateInstallCommand()
    {
        $this->app->singleton('command.migrate.install', function ($app) {
            return new InstallCommand($app['migration.repository']);
        });
    }

ありましたね。InstallCommand インスタンスが返ってくるようです。
InstallCommand::run() は先程読みました。ぐるぐるまわって自身の execute() メソッドがコールされ、コマンドアプリケーションから自身の handle() をコールする手続きでした。
InstallCommand::handle() を見てみましょう。

Illuminate\Database\Console\Migrations\InstallCommand::handle() | 関連メソッド

    /**
     * Execute the console command.
     *
     * @return void
     */
    public function handle()
    {
        $this->repository->setSource($this->input->getOption('database'));

        $this->repository->createRepository();

        $this->info('Migration table created successfully.');
    }
    /**
     * Create a new migration install command instance.
     *
     * @param  \Illuminate\Database\Migrations\MigrationRepositoryInterface  $repository
     * @return void
     */
    public function __construct(MigrationRepositoryInterface $repository)
    {
        parent::__construct();

        $this->repository = $repository;
    }

MigrationServiceProvider::registerMigrateInstallCommand() でコマンドをアプリケーションコンテナに結合する際に、 InstallCommand インスタンスに引数 $app['migration.repository'] が渡されていました。
InstallCommand クラスではコンストラクタで $repository に引数を入れています。
つまり、handle() メソッド内の $this->repository は Illuminate\Database\Migrations\DatabaseMigrationRepository インスタンスです。見てみましょう。

Illuminate\Database\Migrations\DatabaseMigrationRepository::setSource() | createRepository ()

    /**
     * Set the information source to gather data.
     *
     * @param  string  $name
     * @return void
     */
    public function setSource($name)
    {
        $this->connection = $name;
    }
    /**
     * Create the migration repository data store.
     *
     * @return void
     */
    public function createRepository()
    {
        $schema = $this->getConnection()->getSchemaBuilder();

        $schema->create($this->table, function ($table) {
            // The migrations table is responsible for keeping track of which of the
            // migrations have actually run for the application. We'll create the
            // table to hold the migration file's path as well as the batch ID.
            $table->increments('id');
            $table->string('migration');
            $table->integer('batch');
        });
    }
    /**
     * Create a new database migration repository instance.
     *
     * @param  \Illuminate\Database\ConnectionResolverInterface  $resolver
     * @param  string  $table
     * @return void
     */
    public function __construct(Resolver $resolver, $table)
    {
        $this->table = $table;
        $this->resolver = $resolver;
    }
    /**
     * Resolve the database connection instance.
     *
     * @return \Illuminate\Database\Connection
     */
    public function getConnection()
    {
        return $this->resolver->connection($this->connection);
    }

setSource() に $this->input->getOption('database') を引数として渡しています。接続名ですね。
次に repository->createRepository() をコールしています。
createRepository() では、スキーマビルダーに create() メソッドをコールしています。
引数は $this->table とクロージャーです。
$this->table は MigrationServiceProvider::registerRepository() で DatabaseMigrationRepository を生成する際に第二引数として $app['config']['database.migrations'] を渡しています。DatabaseMigrationRepository のコンストラクタで渡された引数を $this->table に代入しています。つまり、デフォルトでは 「migrations」 です。
同様に this->resolver は $app['db'] つまり、DatabaseManager ですね。
DatabaseManager::connection() メソッドに接続名を渡し接続を受け取ります。受け取った接続の getSchemaBuilder() をコールします。接続は MySqlConnection ですから戻ってくるのは MySqlBuilder ですね。だいぶ読めるようになってきましたね。
では、Builder::create() を見てみましょう。

Illuminate\Database\Schema\Builder::create() | 関連メソッド

    /**
     * Create a new table on the schema.
     *
     * @param  string  $table
     * @param  \Closure  $callback
     * @return void
     */
    public function create($table, Closure $callback)
    {
        $this->build(tap($this->createBlueprint($table), function ($blueprint) use ($callback) {
            $blueprint->create();

            $callback($blueprint);
        }));
    }
    /**
     * Execute the blueprint to build / modify the table.
     *
     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
     * @return void
     */
    protected function build(Blueprint $blueprint)
    {
        $blueprint->build($this->connection, $this->grammar);
    }
    /**
     * Create a new command set with a Closure.
     *
     * @param  string  $table
     * @param  \Closure|null  $callback
     * @return \Illuminate\Database\Schema\Blueprint
     */
    protected function createBlueprint($table, Closure $callback = null)
    {
        $prefix = $this->connection->getConfig('prefix_indexes')
                    ? $this->connection->getConfig('prefix')
                    : '';

        if (isset($this->resolver)) {
            return call_user_func($this->resolver, $table, $callback, $prefix);
        }

        return new Blueprint($table, $callback, $prefix);
    }

tap() メソッドに createBlueprint() メソッドをコールしたものとクロージャーを渡した戻り値を build() メソッドに渡しています。

接続設定の prefix_indexes が true なら 接続設定の prefix を false なら空文字を $prefix に代入します。
接続設定は PROJECT_ROOT/config/database.php の内容です。
$this->resolver が null でなければ、call_user_func() にコールバックとして $this->resolver にテーブル名、コールバック関数、プレフィックスを渡しコールし戻ってきたものを戻します。
セットされていなければ、Blueprint インスタンスをテーブル名、コールバック関数、プレフィックスを渡して生成したものを返します。

Builder::resolver の更新インターフェースは Builder::blueprintResolver() メソッドのみですので今回は null ですね。
Blueprint インスタンスが生成されます。Blueprint クラスのコンストラクタを見てみましょう。

Illuminate\Database\Schema\Blueprint::__construct()

    /**
     * Create a new schema blueprint.
     *
     * @param  string  $table
     * @param  \Closure|null  $callback
     * @param  string  $prefix
     * @return void
     */
    public function __construct($table, Closure $callback = null, $prefix = '')
    {
        $this->table = $table;
        $this->prefix = $prefix;

        if (! is_null($callback)) {
            $callback($this);
        }
    }

引数として受け取ったテーブル名とプレフィックスを変数に代入します。引数にクロージャーが渡されていた場合は自身を引数にコールします。
今回はクロージャーは渡されていません。

ここで生成されたクロージャーが Builder::create() メソッドの tap() ヘルパ関数に渡されます。第二引数のクロージャーを第一引数を引数として渡してコールするんでしたね。

        $this->build(tap($this->createBlueprint($table), function ($blueprint) use ($callback) {
            $blueprint->create();
            $callback($blueprint);
        }));

このクロージャーに渡されている $callback は DatabaseMigrationRepository::createRepository() で渡されている以下です。

        $schema->create($this->table, function ($table) {
            // The migrations table is responsible for keeping track of which of the
            // migrations have actually run for the application. We'll create the
            // table to hold the migration file's path as well as the batch ID.
            $table->increments('id');
            $table->string('migration');
            $table->integer('batch');
        });

まず、渡された Blueprint インスタンスの create() メソッドをコールしています。
見てみましょう。

Illuminate\Database\Schema\Blueprint::create() | 関連メソッド

    /**
     * Indicate that the table needs to be created.
     *
     * @return \Illuminate\Support\Fluent
     */
    public function create()
    {
        return $this->addCommand('create');
    }
    /**
     * Add a new command to the blueprint.
     *
     * @param  string  $name
     * @param  array  $parameters
     * @return \Illuminate\Support\Fluent
     */
    protected function addCommand($name, array $parameters = [])
    {
        $this->commands[] = $command = $this->createCommand($name, $parameters);

        return $command;
    }
    /**
     * Create a new Fluent command.
     *
     * @param  string  $name
     * @param  array  $parameters
     * @return \Illuminate\Support\Fluent
     */
    protected function createCommand($name, array $parameters = [])
    {
        return new Fluent(array_merge(compact('name'), $parameters));
    }

Illuminate\Support\Fluent::__construct | 関連メソッド

class Fluent implements Arrayable, ArrayAccess, Jsonable, JsonSerializable
{
    /**
     * All of the attributes set on the fluent instance.
     *
     * @var array
     */
    protected $attributes = [];

    /**
     * Create a new fluent instance.
     *
     * @param  array|object  $attributes
     * @return void
     */
    public function __construct($attributes = [])
    {
        foreach ($attributes as $key => $value) {
            $this->attributes[$key] = $value;
        }
    }

    /**
     * Get an attribute from the fluent instance.
     *
     * @param  string  $key
     * @param  mixed  $default
     * @return mixed
     */
    public function get($key, $default = null)
    {
        if (array_key_exists($key, $this->attributes)) {
            return $this->attributes[$key];
        }

        return value($default);
    }

Fluent クラスはコードをざっと見た感じ、コンストラクタや _set() で設定した値を以下の形で取得できるクラスのようです。

$fluent = new Fluent(['key' => 'value']);
var_dump($fluent->key); // string(5) "value"

ArrayAccess も可能で格納する情報は JSON 型でもいいみたいですね。

続きを見ましょう。

$this->table にテーブル名「migrations 」を代入し、$this->commands[] に「'name' => 'create' 」というコマンドが登録された blueprint インスタンスを引数にコールバックをコールします。
コールバックの内容を追いましょう。

Illuminate\Database\Schema\Blueprint::increments() | 関連メソッド

    /**
     * Create a new auto-incrementing integer (4-byte) column on the table.
     *
     * @param  string  $column
     * @return \Illuminate\Database\Schema\ColumnDefinition
     */
    public function increments($column)
    {
        return $this->unsignedInteger($column, true);
    }
    /**
     * Create a new unsigned integer (4-byte) column on the table.
     *
     * @param  string  $column
     * @param  bool  $autoIncrement
     * @return \Illuminate\Database\Schema\ColumnDefinition
     */
    public function unsignedInteger($column, $autoIncrement = false)
    {
        return $this->integer($column, $autoIncrement, true);
    }
    /**
     * Create a new integer (4-byte) column on the table.
     *
     * @param  string  $column
     * @param  bool  $autoIncrement
     * @param  bool  $unsigned
     * @return \Illuminate\Database\Schema\ColumnDefinition
     */
    public function integer($column, $autoIncrement = false, $unsigned = false)
    {
        return $this->addColumn('integer', $column, compact('autoIncrement', 'unsigned'));
    }
    /**
     * Add a new column to the blueprint.
     *
     * @param  string  $type
     * @param  string  $name
     * @param  array  $parameters
     * @return \Illuminate\Database\Schema\ColumnDefinition
     */
    public function addColumn($type, $name, array $parameters = [])
    {
        $this->columns[] = $column = new ColumnDefinition(
            array_merge(compact('type', 'name'), $parameters)
        );

        return $column;
    }

increments() > unsignedInteger() > integer() とカラム名に加えてパラメーターをつなぎ合わせて addColumn() メソッドをコールしています。
addColumn() メソッドは受け取った引数を渡して ColumnDefinition インスタンスを生成しています。

ColumnDefinition インスタンスを生成する時に渡される引数は以下のようなイメージです。

array(4) {
  ["type"]=> string(7) "integer"
  ["name"]=> string(2) "id"
  ["autoIncrement"]=> bool(true)
  ["unsigned"]=> bool(true)
}

ColumnDefinition は先程の Fluent クラスを継承するクラスです。テーブル情報を管理するためのインスタンスでしょう。生成された ColumnDefinition インスタンスを columns[] に代入し、そのまま戻しています。
string() メソッド、integer() メソッド共に同様の流れです。

tap() ヘルパ関数の戻り値はクロージャーに引数で渡した値でした。つまり、いろいろな手続きを踏んだ $blueprint が戻ってきます。これを引数に build() する流れとなります。

その１４に続く。

The post 【フレームワークを読む】Laravelのマイグレーションファイルは何をしているのか？ ：その１３：MigrateCommand::handle() appeared first on XIONCC.

Illuminate/Console/Command::execute()

    /**
     * Execute the console command.
     *
     * @param  \Symfony\Component\Console\Input\InputInterface  $input
     * @param  \Symfony\Component\Console\Output\OutputInterface  $output
     * @return int
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        return (int) $this->laravel->call([$this, 'handle']);
    }

コマンドアプリケーションコンテナの call() を引数に自身と 「handle」を配列にして渡しコールしています。しばらく Symfony だったので Laravel側は久しぶりですね。見てみましょう。

Illuminate\Container\Container::call()

    /**
     * Call the given Closure / class@method and inject its dependencies.
     *
     * @param  callable|string  $callback
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     */
    public function call($callback, array $parameters = [], $defaultMethod = null)
    {
        return BoundMethod::call($this, $callback, $parameters, $defaultMethod);
    }

Illuminate\Container\BoundMethod::call()

    /**
     * Call the given Closure / class@method and inject its dependencies.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  callable|string  $callback
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     *
     * @throws \ReflectionException
     * @throws \InvalidArgumentException
     */
    public static function call($container, $callback, array $parameters = [], $defaultMethod = null)
    {
        if (static::isCallableWithAtSign($callback) || $defaultMethod) {
            return static::callClass($container, $callback, $parameters, $defaultMethod);
        }

        return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
            return call_user_func_array(
                $callback, static::getMethodDependencies($container, $callback, $parameters)
            );
        });
    }
    /**
     * Determine if the given string is in Class@method syntax.
     *
     * @param  mixed  $callback
     * @return bool
     */
    protected static function isCallableWithAtSign($callback)
    {
        return is_string($callback) && strpos($callback, '@') !== false;
    }
    /**
     * Call a string reference to a class using Class@method syntax.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  string  $target
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     *
     * @throws \InvalidArgumentException
     */
    protected static function callClass($container, $target, array $parameters = [], $defaultMethod = null)
    {
        $segments = explode('@', $target);

        // We will assume an @ sign is used to delimit the class name from the method
        // name. We will split on this @ sign and then build a callable array that
        // we can pass right back into the "call" method for dependency binding.
        $method = count($segments) === 2
                        ? $segments[1] : $defaultMethod;

        if (is_null($method)) {
            throw new InvalidArgumentException('Method not provided.');
        }

        return static::call(
            $container, [$container->make($segments[0]), $method], $parameters
        );
    }

Illuminate\Container\Container::call()

自身と受け取った引数をそのまま BoundMethod::call() メソッドにスタティックコールして戻り値をそのまま戻しています。

Illuminate\Container\BoundMethod::call()

isCallableWithAtSign() メソッドを引数にコールバック関数を渡した戻り値が true 若しくはデフォルトメソッドが引数として渡されている場合は callClass メソッドを引数そのまま渡してコールします。
isCallableWithAtSign() メソッドは コールバック関数として渡された第一引数がストリング型で且つ「@」が含まれている場合 true を戻します。これは、「クラス名@メソッド名」という形でコールバックする関数を指定する事ができるようにしています。

callClass メソッドは、コールバック関数として受け取ったストリングを 「@」で explode() し、$segments に代入します。$segments の配列の数が２ならば一番目、そうでなければデフォルトメソッドを $method に代入します。
$method が null ならば「Method not provided.」とメッセージを添えて例外 InvalidArgumentException をスローします。
コマンドアプリケーションコンテナに $segments[0] と $method を使い make し、それをコールバック関数として call() メソッドをコールします。

isCallableWithAtSign() の戻り値が false だった場合、callBoundMethod() メソッドをコマンドアプリケーションとコールバック関数とクロージャーを引数に渡しコールします。
渡されているクロージャーを見てみましょう。

function () use ($container, $callback, $parameters) {
    return call_user_func_array(
        $callback, static::getMethodDependencies($container, $callback, $parameters)
    );
}

Illuminate\Container\BoundMethod::getMethodDependencies() | 関連メソッド

    /*
     * Get all dependencies for a given method.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  callable|string  $callback
     * @param  array  $parameters
     * @return array
     *
     * @throws \ReflectionException
     */
    protected static function getMethodDependencies($container, $callback, array $parameters = [])
    {
        $dependencies = [];

        foreach (static::getCallReflector($callback)->getParameters() as $parameter) {
            static::addDependencyForCallParameter($container, $parameter, $parameters, $dependencies);
        }

        return array_merge($dependencies, $parameters);
    }
    /**
     * Get the proper reflection instance for the given callback.
     *
     * @param  callable|string  $callback
     * @return \ReflectionFunctionAbstract
     *
     * @throws \ReflectionException
     */
    protected static function getCallReflector($callback)
    {
        if (is_string($callback) && strpos($callback, '::') !== false) {
            $callback = explode('::', $callback);
        } elseif (is_object($callback) && ! $callback instanceof Closure) {
            $callback = [$callback, '__invoke'];
        }

        return is_array($callback)
                        ? new ReflectionMethod($callback[0], $callback[1])
                        : new ReflectionFunction($callback);
    }
    /**
     * Get the dependency for the given call parameter.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  \ReflectionParameter  $parameter
     * @param  array  $parameters
     * @param  array  $dependencies
     * @return void
     */
    protected static function addDependencyForCallParameter($container, $parameter,
                                                            array &$parameters, &$dependencies)
    {
        if (array_key_exists($parameter->name, $parameters)) {
            $dependencies[] = $parameters[$parameter->name];

            unset($parameters[$parameter->name]);
        } elseif ($parameter->getClass() && array_key_exists($parameter->getClass()->name, $parameters)) {
            $dependencies[] = $parameters[$parameter->getClass()->name];

            unset($parameters[$parameter->getClass()->name]);
        } elseif ($parameter->getClass()) {
            $dependencies[] = $container->make($parameter->getClass()->name);
        } elseif ($parameter->isDefaultValueAvailable()) {
            $dependencies[] = $parameter->getDefaultValue();
        }
    }

call_user_func_array() してます。引数はコールバック関数と getMethodDependencies() です。
まずは getMethodDependencies() メソッドを見てみましょう。

getCallReflector() メソッドの戻り値の getParameters() を foreach してます。
getCallReflector()メソッドを見てみましょう。

コールバックがストリング型で「::」を含む場合は、「::」 で explode() した結果の配列を $callback に代入します。
コールバックがクロージャーの場合は、それを０番目、１番目に「__invoke」を入れた配列を $callback に代入します。
コールバックが配列だった場合は、ReflectionMethod インスタンスを引数にコールバック配列の０番目と１番目を渡して生成して返します。
そうでなかった場合は ReflectionFunction インスタンスを引数にコールバックを渡して生成したものを戻します。
今回は「[$this, ‘handle’]」が入っていますので、 ReflectionMethod が生成されます。

ReflectionMethod インスタンス及び ReflectionFunction インスタンスの getParameters() メソッドは共にパラメータを ReflectionParameter オブジェクトの配列で返します。

つまり、ReflectionParameter オブジェクトの配列を foreach で回すわけですね。
foreach の中で、addDependencyForCallParameter() メソッドを コマンドアプリケーションコンテナ、ReflectionParameter オブジェクトの配列の中身、参照渡しでコマンドの引数、そして参照渡しで依存関係配列を引数として渡しコールします。

addDependencyForCallParameter() メソッドを見てみましょう。
$parameter->name は ReflectionParameter クラスで $name は読込専用でパラメータ名が格納されています。つまり、コマンド引数のパラメーターの中にコールバック関数のパラメータ名がキーとなる値が存在していた場合、依存関係配列にパラメーター名をキーとした配列の値を追加し、同じくパラメーター名をキーとしたコマンド引数の配列を unset で削除します。

そうでない場合、
ReflectionParameter::getClass() メソッドはタイプヒント付きのクラスを取得します。取得したクラスは ReflectionClass インスタンスで $name はクラス名です。
依存関係にコマンド引数のクラス名をキーとした値を追加し、同じくクラス名をキーとしたコマンド引数の配列を unset で削除します。

そうでない場合、
$parameter->getClass() でクラス名が取得できた場合は、コマンドアプリケーションコンテナで $parameter->getClass()->name で取得したクラス名で make() したものを依存関係配列に追加します。

そうでない場合、$parameter->isDefaultValueAvailable() でデフォルト値が存在するか調べています。
もし、存在する場合は依存関係に $parameter->getDefaultValue() でデフォルト値を取得したものを追加します。

ReflectionParameter 等の詳細は php.net を参照してください。

依存関係の解決の処理のようです。ここらへんは複雑になってきましたので、追いきれていない感じがします。
別の機会を作ってもう少し整理したいと思います。
続きを読みましょう。

addDependencyForCallParameter() メソッドで依存関係を調べて戻ってきた配列とコマンド引数配列を array_merge で結合して戻したものが call_user_func_array() で実行されます。

もう一度流れを見てみましょう。

Illuminate/Console/Command::execute()

    /**
     * Execute the console command.
     *
     * @param  \Symfony\Component\Console\Input\InputInterface  $input
     * @param  \Symfony\Component\Console\Output\OutputInterface  $output
     * @return int
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        return (int) $this->laravel->call([$this, 'handle']);
    }

Illuminate\Container\Container::call()

    /**
     * Call the given Closure / class@method and inject its dependencies.
     *
     * @param  callable|string  $callback
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     */
    public function call($callback, array $parameters = [], $defaultMethod = null)
    {
        return BoundMethod::call($this, $callback, $parameters, $defaultMethod);
    }

Illuminate\Container\BoundMethod::call() | 抜粋

function () use ($container, $callback, $parameters) {
    return call_user_func_array(
        $callback, static::getMethodDependencies($container, $callback, $parameters)
    );
}

call_user_func_array() の use に渡される変数は、 $container がコマンドアプリケーションコンテナ、$callback が [$this, 'handle']、$parameters が [] ですね。
[$this, 'handle'] に対して static::getMethodDependencies($container, $callback, $parameters) を引数に渡してコールします。
getMethodDependencies() は getCallReflector() でコールバックを使い、new ReflectionMethod($callback[0], $callback[1]) をで ReflectionMethod を生成しています。つまり、MigrateCommand::handle() がコールされる結果となります。

いよいよ MigrateCommand::handle() を読むろころまで来ました。
その１３に続きます。

The post 【フレームワークを読む】Laravelのマイグレーションファイルは何をしているのか？ ：その１２：Console\Command::execute() appeared first on XIONCC.

$exitCode = $this->doRunCommand($command, $input, $output);

コマンドと入出力が引数として渡されてます。
見てみましょう。

Symfony\Component\Console\Application::doRunCommand()

    /**
     * Runs the current command.
     *
     * If an event dispatcher has been attached to the application,
     * events are also dispatched during the life-cycle of the command.
     *
     * @return int 0 if everything went fine, or an error code
     */
    protected function doRunCommand(Command $command, InputInterface $input, OutputInterface $output)
    {
        foreach ($command->getHelperSet() as $helper) {
            if ($helper instanceof InputAwareInterface) {
                $helper->setInput($input);
            }
        }

        if (null === $this->dispatcher) {
            return $command->run($input, $output);
        }

        // bind before the console.command event, so the listeners have access to input options/arguments
        try {
            $command->mergeApplicationDefinition();
            $input->bind($command->getDefinition());
        } catch (ExceptionInterface $e) {
            // ignore invalid options/arguments for now, to allow the event listeners to customize the InputDefinition
        }

        $event = new ConsoleCommandEvent($command, $input, $output);
        $e = null;

        try {
            $this->dispatcher->dispatch($event, ConsoleEvents::COMMAND);

            if ($event->commandShouldRun()) {
                $exitCode = $command->run($input, $output);
            } else {
                $exitCode = ConsoleCommandEvent::RETURN_CODE_DISABLED;
            }
        } catch (\Throwable $e) {
            $event = new ConsoleErrorEvent($input, $output, $e, $command);
            $this->dispatcher->dispatch($event, ConsoleEvents::ERROR);
            $e = $event->getError();

            if (0 === $exitCode = $event->getExitCode()) {
                $e = null;
            }
        }

        $event = new ConsoleTerminateEvent($command, $input, $output, $exitCode);
        $this->dispatcher->dispatch($event, ConsoleEvents::TERMINATE);

        if (null !== $e) {
            throw $e;
        }

        return $event->getExitCode();
    }

Symfony\Component\Console\Application::doRunCommand()

$command->getHelperSet() を foreach で回します。おそらく今回はフォーマッタ、デバグフォーマッタ、プロセス、クエスチョンのヘルパが入っていると思います。回したインスタンスが InputAwareInterface だった場合、 setInput() に入力を渡しています。おそらく入力対応インターフェースを持ったヘルパで使うのでしょう。

$this->dispatcher を検証し null ならば $command->run() します。
$this->dispatcher は setDispatcher() で設定され、 EventDispatcherInterface インスタンスが代入されます。
イベント登録されている場合の処理が後に続きます。
今回はイベント登録されていませんのでここは通りません。

$command に入っているのは以下です。

function ($app) {
    return new MigrateCommand($app['migrator']);
}

見てみましょう。

Illuminate\Database\Console\Migrations\MigrateCommand

    /**
     * Create a new migration command instance.
     *
     * @param  \Illuminate\Database\Migrations\Migrator  $migrator
     * @return void
     */
    public function __construct(Migrator $migrator)
    {
        parent::__construct();

        $this->migrator = $migrator;
    }

Illuminate\Database\Console\Migrations\BaseCommand

class BaseCommand extends Command
{
}

Illuminate\Console\Command

    /**
     * Create a new console command instance.
     *
     * @return void
     */
    public function __construct()
    {
        // We will go ahead and set the name, description, and parameters on console
        // commands just to make things a little easier on the developer. This is
        // so they don't have to all be manually specified in the constructors.
        if (isset($this->signature)) {
            $this->configureUsingFluentDefinition();
        } else {
            parent::__construct($this->name);
        }

        // Once we have constructed the command, we'll set the description and other
        // related properties of the command. If a signature wasn't used to build
        // the command we'll set the arguments and the options on this command.
        $this->setDescription((string) $this->description);

        $this->setHelp((string) $this->help);

        $this->setHidden($this->isHidden());

        if (! isset($this->signature)) {
            $this->specifyParameters();
        }
    }
    /**
     * Run the console command.
     *
     * @param  \Symfony\Component\Console\Input\InputInterface  $input
     * @param  \Symfony\Component\Console\Output\OutputInterface  $output
     * @return int
     */
    public function run(InputInterface $input, OutputInterface $output)
    {
        $this->output = $this->laravel->make(
            OutputStyle::class, ['input' => $input, 'output' => $output]
        );

        return parent::run(
            $this->input = $input, $this->output
        );
    }

Symfony\Component\Console\Command\Command::__construct() | run() | 関連メソッド

    /**
     * @param string|null $name The name of the command; passing null means it must be set in configure()
     *
     * @throws LogicException When the command name is empty
     */
    public function __construct(string $name = null)
    {
        $this->definition = new InputDefinition();

        if (null !== $name || null !== $name = static::getDefaultName()) {
            $this->setName($name);
        }

        $this->configure();
    }
    /**
     * Configures the current command.
     */
    protected function configure()
    {
    }

Symfony\Component\Console\Command\Command::run()

MigrateCommand インスタンスは生成される時に渡される引数 $app['migrator'] を変数 $this->migrator に代入します。 スーパークラスのインストラクタをコールします。
MigrateCommand クラスは BaseCommand を継承しています。しかし、 BaseCommand にはコンストラクタがありません。BaseCommand は Command クラスを継承していますのでこのクラスのコンストラクタがコールされます。
まず、$this->signature を検証しています。この部分は前回のその１０で読みましたね。署名に設定されたストリングからコマンド名とオプションの解説をパースして登録します。そして、スーパークラスの Symfony\Component\Console\Command\Command のコンストラクタがコールされ、説明文とヘルプと非表示フラグをセットします。
Symfony\Component\Console\Command\Command はクラス変数 $definition に InputDefinition インスタンスを生成し代入します。自身の configure() メソッドをコールしますが、中身は空です。

$command の中には MigrateCommand が生成されて入っているのはわかりました。

MigrateCommand::run() メソッドがコールされます。

MigrateCommand クラス自体に run() メソッドはありません。継承している BaseCommand クラスにもありません。さらに継承している Command に定義してあります。内容は以下です。

Illuminate\Console\Command::run()

    /**
     * Run the console command.
     *
     * @param  \Symfony\Component\Console\Input\InputInterface  $input
     * @param  \Symfony\Component\Console\Output\OutputInterface  $output
     * @return int
     */
    public function run(InputInterface $input, OutputInterface $output)
    {
        $this->output = $this->laravel->make(
            OutputStyle::class, ['input' => $input, 'output' => $output]
        );

        return parent::run(
            $this->input = $input, $this->output
        );
    }

Illuminate\Console\OutputStyle::__construct()

    /**
     * Create a new Console OutputStyle instance.
     *
     * @param  \Symfony\Component\Console\Input\InputInterface  $input
     * @param  \Symfony\Component\Console\Output\OutputInterface  $output
     * @return void
     */
    public function __construct(InputInterface $input, OutputInterface $output)
    {
        $this->output = $output;

        parent::__construct($input, $output);
    }

Illuminate\Console\Command::run()

OutputStyle としてコマンドアプリケーションに入出力を配列で登録し、$this->output に代入します。
OutputStyle は Symfony\Component\Console\Style\SymfonyStyle を継承するクラスで、出力装飾に関するクラスのようです。

スーパークラスの run() メソッドを入出力を渡してコールします。
見てみましょう。

Symfony\Component\Console\Command\Command::run()

    /**
     * Runs the command.
     *
     * The code to execute is either defined directly with the
     * setCode() method or by overriding the execute() method
     * in a sub-class.
     *
     * @return int The command exit code
     *
     * @throws \Exception When binding input fails. Bypass this by calling {@link ignoreValidationErrors()}.
     *
     * @see setCode()
     * @see execute()
     */
    public function run(InputInterface $input, OutputInterface $output)
    {
        // force the creation of the synopsis before the merge with the app definition
        $this->getSynopsis(true);
        $this->getSynopsis(false);

        // add the application arguments and options
        $this->mergeApplicationDefinition();

        // bind the input against the command specific arguments/options
        try {
            $input->bind($this->definition);
        } catch (ExceptionInterface $e) {
            if (!$this->ignoreValidationErrors) {
                throw $e;
            }
        }

        $this->initialize($input, $output);

        if (null !== $this->processTitle) {
            if (\function_exists('cli_set_process_title')) {
                if (!@cli_set_process_title($this->processTitle)) {
                    if ('Darwin' === PHP_OS) {
                        $output->writeln('Running "cli_set_process_title" as an unprivileged user is not supported on MacOS.', OutputInterface::VERBOSITY_VERY_VERBOSE);
                    } else {
                        cli_set_process_title($this->processTitle);
                    }
                }
            } elseif (\function_exists('setproctitle')) {
                setproctitle($this->processTitle);
            } elseif (OutputInterface::VERBOSITY_VERY_VERBOSE === $output->getVerbosity()) {
                $output->writeln('Install the proctitle PECL to be able to change the process title.');
            }
        }

        if ($input->isInteractive()) {
            $this->interact($input, $output);
        }

        // The command name argument is often omitted when a command is executed directly with its run() method.
        // It would fail the validation if we didn't make sure the command argument is present,
        // since it's required by the application.
        if ($input->hasArgument('command') && null === $input->getArgument('command')) {
            $input->setArgument('command', $this->getName());
        }

        $input->validate();

        if ($this->code) {
            $statusCode = ($this->code)($input, $output);
        } else {
            $statusCode = $this->execute($input, $output);

            if (!\is_int($statusCode)) {
                throw new \TypeError(sprintf('Return value of "%s::execute()" must be of the type int, %s returned.', static::class, \gettype($statusCode)));
            }
        }

        return is_numeric($statusCode) ? (int) $statusCode : 0;
    }
    /**
     * Returns the synopsis for the command.
     *
     * @param bool $short Whether to show the short version of the synopsis (with options folded) or not
     *
     * @return string The synopsis
     */
    public function getSynopsis(bool $short = false)
    {
        $key = $short ? 'short' : 'long';

        if (!isset($this->synopsis[$key])) {
            $this->synopsis[$key] = trim(sprintf('%s %s', $this->name, $this->definition->getSynopsis($short)));
        }

        return $this->synopsis[$key];
    }

Symfony\Component\Console\Command\Command::run()

getSynopsis() を引数に true を入れてコールします。
getSynopsis() を引数に false を入れてコールします。
true と false を１回ずつ叩くことで概要の略と詳細を確実に生成しておきます。
mergeApplicationDefinition() メソッドが叩かれています。
見てみましょう。

Symfony\Component\Console\Command\Command::mergeApplicationDefinition()

    /**
     * Merges the application definition with the command definition.
     *
     * This method is not part of public API and should not be used directly.
     *
     * @param bool $mergeArgs Whether to merge or not the Application definition arguments to Command definition arguments
     */
    public function mergeApplicationDefinition(bool $mergeArgs = true)
    {
        if (null === $this->application || (true === $this->applicationDefinitionMerged && ($this->applicationDefinitionMergedWithArgs || !$mergeArgs))) {
            return;
        }

        $this->definition->addOptions($this->application->getDefinition()->getOptions());

        $this->applicationDefinitionMerged = true;

        if ($mergeArgs) {
            $currentArguments = $this->definition->getArguments();
            $this->definition->setArguments($this->application->getDefinition()->getArguments());
            $this->definition->addArguments($currentArguments);

            $this->applicationDefinitionMergedWithArgs = true;
        }
    }

Symfony\Component\Console\Command\Command::mergeApplicationDefinition()

コマンドアプリケーションが null 若しくはマージ済み、若しくはマージするかどうかの引数が false の場合、そのまま戻します。
そうでない場合はコマンド定義にアプリケーション定義と引数をマージし、マージ済みフラグを true に設定します。

次は以下が実行されます。

$input->bind($this->definition);

見てみましょう。

Symfony\Component\Console\Input\bind()

    /**
     * Binds the current Input instance with the given arguments and options.
     *
     * @throws RuntimeException
     */
    public function bind(InputDefinition $definition)
    {
        $this->arguments = [];
        $this->options = [];
        $this->definition = $definition;

        $this->parse();
    }

Symfony\Component\Console\ArgvInput\parse()

    /**
     * Processes command line arguments.
     */
    protected function parse()
    {
        $parseOptions = true;
        $this->parsed = $this->tokens;
        while (null !== $token = array_shift($this->parsed)) {
            if ($parseOptions && '' == $token) {
                $this->parseArgument($token);
            } elseif ($parseOptions && '--' == $token) {
                $parseOptions = false;
            } elseif ($parseOptions && 0 === strpos($token, '--')) {
                $this->parseLongOption($token);
            } elseif ($parseOptions && '-' === $token[0] && '-' !== $token) {
                $this->parseShortOption($token);
            } else {
                $this->parseArgument($token);
            }
        }
    }

Symfony\Component\Console\ArgvInput\parse()

引数とオプションを空の配列で初期化して、 $this->definition に引数として渡された定義を代入します。
今回の場合は $command->getDefinition() で取得したコマンド定義が入ります。
その後 parse() で解析し引数、オプションを登録していきます。

次に以下が実行されています。

$this->initialize($input, $output);

次に $this->processTitle が null かどうか検証しています。
$this->processTitle を設定できるインターフェイスは setProcessTitle() でそのコードドキュメントには 「この機能は、長いプロセスコマンドを作成する場合にのみ使用してください。」とあります。デーモンのようなコマンドを作成する時にプロセス名をセットするためのもののようです。今回は null なのでここは通りません。ざっとみるとプロセス名を設定出来なかった場合の例外処理やメッセージなどのロジックのようです。次を見ましょう。isInteractive() メソッドがコールされています。

    if ($input->isInteractive()) {
        $this->interact($input, $output);
    }

Symfony\Component\Console\Input\Input::interact()

    /**
     * Interacts with the user.
     *
     * This method is executed before the InputDefinition is validated.
     * This means that this is the only place where the command can
     * interactively ask for values of missing required arguments.
     */
    protected function interact(InputInterface $input, OutputInterface $output)
    {
    }

Symfony\Component\Console\Input\Input::isInteractive()

    protected $interactive = true;
    /**
     * Is this input means interactive?
     *
     * @return bool
     */
    public function isInteractive()
    {
        return $this->interactive;
    }
    /**
     * {@inheritdoc}
     */
    public function setInteractive(bool $interactive)
    {
        $this->interactive = $interactive;
    }

        // The command name argument is often omitted when a command is executed directly with its run() method.
        // It would fail the validation if we didn't make sure the command argument is present,
        // since it's required by the application.
        if ($input->hasArgument('command') && null === $input->getArgument('command')) {
            $input->setArgument('command', $this->getName());
        }

コマンド定義に引数「’command’」があり、コマンドラインから受け取った引数「’command’」がなかった場合、コマンド名を設定しています。
コードドキュメントによると、コマンドがrun（）メソッドで直接実行される場合、コマンド名の引数が省略されることがあるため、だそうです。
今回はここは通らなそうです。

$input->validate();

Symfony\Component\Console\Input\Input::validate()

    /**
     * Validates the input.
     *
     * @throws RuntimeException When not enough arguments are given
     */
    public function validate()
    {
        $definition = $this->definition;
        $givenArguments = $this->arguments;

        $missingArguments = array_filter(array_keys($definition->getArguments()), function ($argument) use ($definition, $givenArguments) {
            return !\array_key_exists($argument, $givenArguments) && $definition->getArgument($argument)->isRequired();
        });

        if (\count($missingArguments) > 0) {
            throw new RuntimeException(sprintf('Not enough arguments (missing: "%s").', implode(', ', $missingArguments)));
        }
    }

続きです。

Symfony\Component\Console\Command\Command::run() 抜粋

        if ($this->code) {
            $statusCode = ($this->code)($input, $output);
        } else {
            $statusCode = $this->execute($input, $output);
            if (!\is_int($statusCode)) {
                throw new \TypeError(sprintf('Return value of "%s::execute()" must be of the type int, %s returned.', static::class, \gettype($statusCode)));
            }
        }
        return is_numeric($statusCode) ? (int) $statusCode : 0;

Symfony\Component\Console\Command\Command::execute() | setCode()

    /**
     * Executes the current command.
     *
     * This method is not abstract because you can use this class
     * as a concrete class. In this case, instead of defining the
     * execute() method, you set the code to execute by passing
     * a Closure to the setCode() method.
     *
     * @return int 0 if everything went fine, or an exit code
     *
     * @throws LogicException When this abstract method is not implemented
     *
     * @see setCode()
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        throw new LogicException('You must override the execute() method in the concrete command class.');
    }
    /**
     * Sets the code to execute when running this command.
     *
     * If this method is used, it overrides the code defined
     * in the execute() method.
     *
     * @param callable $code A callable(InputInterface $input, OutputInterface $output)
     *
     * @return $this
     *
     * @throws InvalidArgumentException
     *
     * @see execute()
     */
    public function setCode(callable $code)
    {
        if ($code instanceof \Closure) {
            $r = new \ReflectionFunction($code);
            if (null === $r->getClosureThis()) {
                $code = \Closure::bind($code, $this);
            }
        }

        $this->code = $code;

        return $this;
    }

$this->code が設定されている場合は、それを、されていない場合は、$this->execute() をコールし、戻り値を $statusCode に代入します。 $statusCode が整数型でなかった場合、「sprintf('Return value of "%s::execute()" must be of the type int, %s returned.', static::class, \gettype($statusCode))」のメッセージを添えて例外 TypeError をスローします。
$this->code は setCode() で設定できます。
Symfony\Component\Console\Command\Command を継承し、execute() メソッドをオーバーライドしてコマンド処理を記述する方法の他に、Symfony\Component\Console\Command\Command 自体に setCode() にクロージャーを渡す方法もあるそうです。今回は Illuminate/Console/Command で execute() をオーバーライドしています。
Illuminate/Console/Command::execute() は次の回で読みます。
$statusCode が整数ならばそれを、そうでなければ 0 を戻します。

その１２に続きます。

The post 【フレームワークを読む】Laravelのマイグレーションファイルは何をしているのか？ ：その１１：Console\Application:: doRunCommand() appeared first on XIONCC.

Symfony\Component\Console\Application::find() | 関連メソッド

    /**
     * Finds a command by name or alias.
     *
     * Contrary to get, this command tries to find the best
     * match if you give it an abbreviation of a name or alias.
     *
     * @return Command A Command instance
     *
     * @throws CommandNotFoundException When command name is incorrect or ambiguous
     */
    public function find(string $name)
    {
        $this->init();

        $aliases = [];

        foreach ($this->commands as $command) {
            foreach ($command->getAliases() as $alias) {
                if (!$this->has($alias)) {
                    $this->commands[$alias] = $command;
                }
            }
        }

        if ($this->has($name)) {
            return $this->get($name);
        }

        $allCommands = $this->commandLoader ? array_merge($this->commandLoader->getNames(), array_keys($this->commands)) : array_keys($this->commands);
        $expr = preg_replace_callback('{([^:]+|)}', function ($matches) { return preg_quote($matches[1]).'[^:]*'; }, $name);
        $commands = preg_grep('{^'.$expr.'}', $allCommands);

        if (empty($commands)) {
            $commands = preg_grep('{^'.$expr.'}i', $allCommands);
        }

        // if no commands matched or we just matched namespaces
        if (empty($commands) || \count(preg_grep('{^'.$expr.'$}i', $commands)) < 1) {
            if (false !== $pos = strrpos($name, ':')) {
                // check if a namespace exists and contains commands
                $this->findNamespace(substr($name, 0, $pos));
            }

            $message = sprintf('Command "%s" is not defined.', $name);

            if ($alternatives = $this->findAlternatives($name, $allCommands)) {
                // remove hidden commands
                $alternatives = array_filter($alternatives, function ($name) {
                    return !$this->get($name)->isHidden();
                });

                if (1 == \count($alternatives)) {
                    $message .= "\n\nDid you mean this?\n    ";
                } else {
                    $message .= "\n\nDid you mean one of these?\n    ";
                }
                $message .= implode("\n    ", $alternatives);
            }

            throw new CommandNotFoundException($message, array_values($alternatives));
        }

        // filter out aliases for commands which are already on the list
        if (\count($commands) > 1) {
            $commandList = $this->commandLoader ? array_merge(array_flip($this->commandLoader->getNames()), $this->commands) : $this->commands;
            $commands = array_unique(array_filter($commands, function ($nameOrAlias) use (&$commandList, $commands, &$aliases) {
                if (!$commandList[$nameOrAlias] instanceof Command) {
                    $commandList[$nameOrAlias] = $this->commandLoader->get($nameOrAlias);
                }

                $commandName = $commandList[$nameOrAlias]->getName();

                $aliases[$nameOrAlias] = $commandName;

                return $commandName === $nameOrAlias || !\in_array($commandName, $commands);
            }));
        }

        if (\count($commands) > 1) {
            $usableWidth = $this->terminal->getWidth() - 10;
            $abbrevs = array_values($commands);
            $maxLen = 0;
            foreach ($abbrevs as $abbrev) {
                $maxLen = max(Helper::strlen($abbrev), $maxLen);
            }
            $abbrevs = array_map(function ($cmd) use ($commandList, $usableWidth, $maxLen, &$commands) {
                if ($commandList[$cmd]->isHidden()) {
                    unset($commands[array_search($cmd, $commands)]);

                    return false;
                }

                $abbrev = str_pad($cmd, $maxLen, ' ').' '.$commandList[$cmd]->getDescription();

                return Helper::strlen($abbrev) > $usableWidth ? Helper::substr($abbrev, 0, $usableWidth - 3).'...' : $abbrev;
            }, array_values($commands));

            if (\count($commands) > 1) {
                $suggestions = $this->getAbbreviationSuggestions(array_filter($abbrevs));

                throw new CommandNotFoundException(sprintf("Command \"%s\" is ambiguous.\nDid you mean one of these?\n%s", $name, $suggestions), array_values($commands));
            }
        }

        $command = $this->get(reset($commands));

        if ($command->isHidden()) {
            throw new CommandNotFoundException(sprintf('The command "%s" does not exist.', $name));
        }

        return $command;
    }
    private function init()
    {
        if ($this->initialized) {
            return;
        }
        $this->initialized = true;

        foreach ($this->getDefaultCommands() as $command) {
            $this->add($command);
        }
    }
    /**
     * Adds a command object.
     *
     * If a command with the same name already exists, it will be overridden.
     * If the command is not enabled it will not be added.
     *
     * @return Command|null The registered command if enabled or null
     */
    public function add(Command $command)
    {
        $this->init();

        $command->setApplication($this);

        if (!$command->isEnabled()) {
            $command->setApplication(null);

            return null;
        }

        // Will throw if the command is not correctly initialized.
        $command->getDefinition();

        if (!$command->getName()) {
            throw new LogicException(sprintf('The command defined in "%s" cannot have an empty name.', \get_class($command)));
        }

        $this->commands[$command->getName()] = $command;

        foreach ($command->getAliases() as $alias) {
            $this->commands[$alias] = $command;
        }

        return $command;
    }

Symfony\Component\Console\Application::find()

まず、init() メソッドがコールされます。
init() メソッドでは、$this->initialized が検証され true であればそのまま戻されます。
これまでの流れで $this->initialized にtrue を代入した箇所はありませんでした。そのまま飛ばします。
次に $this->initialized に true を代入します。初期化フラグですね。
foreach で $this->getDefaultCommands() を回し、中身を add() メソッドに渡しています。
$this->getDefaultCommands() の戻り値は以下です。

return [new HelpCommand(), new ListCommand()];

つまり、ヘルプと一覧コマンドが登録されるわけですね。add() メソッドの中でも $this->init() メソッドがコールされています。一度 init() メソッドがコールされれば $this->initialized は true になるのでそのまま戻されるのですが、少し冗長な印象です。どこからコールされてもヘルプと一覧だけは登録したいということなのでしょう。もう少し違う設計もありそうに思いますが、Symfonyの思想的なものなのでしょうか。

次に $command->setApplication() を引数に自身を渡してコールしています。
見てみましょう。

Symfony\Component\Console\Command\Command::setApplication()

    public function setApplication(Application $application = null)
    {
        $this->application = $application;
        if ($application) {
            $this->setHelperSet($application->getHelperSet());
        } else {
            $this->helperSet = null;
        }
    }

    public function setHelperSet(HelperSet $helperSet)
    {
        $this->helperSet = $helperSet;
    }

Symfony\Component\Console\Application::getHelperSet() | 関連メソッド

    /**
     * Get the helper set associated with the command.
     *
     * @return HelperSet The HelperSet instance associated with this command
     */
    public function getHelperSet()
    {
        if (!$this->helperSet) {
            $this->helperSet = $this->getDefaultHelperSet();
        }

        return $this->helperSet;
    }
    /**
     * Gets the default helper set with the helpers that should always be available.
     *
     * @return HelperSet A HelperSet instance
     */
    protected function getDefaultHelperSet()
    {
        return new HelperSet([
            new FormatterHelper(),
            new DebugFormatterHelper(),
            new ProcessHelper(),
            new QuestionHelper(),
        ]);
    }

Command インスタンスの変数にアプリケーションコンテナを代入し、setHelperSet() メソッドをコールしています。引数として $application->getHelperSet() メソッドをコールした戻り値を渡しています。 setHelperSet() は受け取った引数をそのまま $this->helperSet に代入するだけです。
getHelperSet() は $this->helperSet つまりコマンドアプリケーションコンテナの helperSet がセットされていなければ、 getDefaultHelperSet() をコールし戻り値をそれに代入してさらにその値を戻します。つまり Command インスタンスにも同じものが共有されます。内容は、フォーマッタ、デバグフォーマッタ、プロセス、クエスチョンのヘルパです。
ちなみに、ヘルパは setHelperSet() で変更することができます。

次に $command->getDefinition() メソッドをコールしています。

Symfony\Component\Console\Command\Command::getDefinition()

    /**
     * Gets the InputDefinition attached to this Command.
     *
     * @return InputDefinition An InputDefinition instance
     */
    public function getDefinition()
    {
        if (null === $this->definition) {
            throw new LogicException(sprintf('Command class "%s" is not correctly initialized. You probably forgot to call the parent constructor.', static::class));
        }

        return $this->definition;
    }

次に $command->getName() を検証しています。これは 各コマンドが Command クラスを継承して configure() メソッドで設定を構築する時に setName() メソッドで設定するコマンド名です。ない場合は「The command defined in “%s” cannot have an empty name.」というメッセージを添えて例外 LogicException をスローします。
コマンド名があれば $this->commands[] 配列にコマンド名をキーに Command インスタンスを追加します。
コマンドにコマンドエイリアスが登録されていた場合、コマンドアプリケーションにもエイリアス登録します。
そのまま Command インスタンスを戻します。
コール元の init() の foreach では戻り値を受け取っていません。 init の処理完了です。

その８で、Symfony\Component\Console\Application::add() までたどり着いたところで一旦引き返しました。
その時コールされた add() の挙動は先程理解しました。

$this->commands[$alias] = $command;

protected $providers = [
    ArtisanServiceProvider::class,
    MigrationServiceProvider::class,
    ComposerServiceProvider::class,
];

Illuminate\Database\MigrationServiceProvider 抜粋

    /**
     * The commands to be registered.
     *
     * @var array
     */
    protected $commands = [
        'Migrate' => 'command.migrate',
        'MigrateFresh' => 'command.migrate.fresh',
        'MigrateInstall' => 'command.migrate.install',
        'MigrateRefresh' => 'command.migrate.refresh',
        'MigrateReset' => 'command.migrate.reset',
        'MigrateRollback' => 'command.migrate.rollback',
        'MigrateStatus' => 'command.migrate.status',
        'MigrateMake' => 'command.migrate.make',
    ];

    /**
     * Register the service provider.
     *
     * @return void
     */
    public function register()
    {
        $this->registerRepository();

        $this->registerMigrator();

        $this->registerCreator();

        $this->registerCommands($this->commands);
    }

    /**
     * Register the migration repository service.
     *
     * @return void
     */
    protected function registerRepository()
    {
        $this->app->singleton('migration.repository', function ($app) {
            $table = $app['config']['database.migrations'];

            return new DatabaseMigrationRepository($app['db'], $table);
        });
    }

    /**
     * Register the migrator service.
     *
     * @return void
     */
    protected function registerMigrator()
    {
        // The migrator is responsible for actually running and rollback the migration
        // files in the application. We'll pass in our database connection resolver
        // so the migrator can resolve any of these connections when it needs to.
        $this->app->singleton('migrator', function ($app) {
            $repository = $app['migration.repository'];

            return new Migrator($repository, $app['db'], $app['files'], $app['events']);
        });
    }

    /**
     * Register the migration creator.
     *
     * @return void
     */
    protected function registerCreator()
    {
        $this->app->singleton('migration.creator', function ($app) {
            return new MigrationCreator($app['files'], $app->basePath('stubs'));
        });
    }

    /**
     * Register the given commands.
     *
     * @param  array  $commands
     * @return void
     */
    protected function registerCommands(array $commands)
    {
        foreach (array_keys($commands) as $command) {
            call_user_func_array([$this, "register{$command}Command"], []);
        }

        $this->commands(array_values($commands));
    }
    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerMigrateCommand()
    {
        $this->app->singleton('command.migrate', function ($app) {
            return new MigrateCommand($app['migrator']);
        });
    }

やはり、そのものズバリの 'Migrate' => 'command.migrate' がありました。
構造は以前読んだ ArtisanServiceProvider とほぼ同じですね。違う点は migrator コマンドを登録する際に database.migrations を migration.repository として Migrator インスタンスに渡しているところ、さらに migration.creator として MigrationCreator インスタンスをアプリケーションコンテナに登録したファイルシステムを引数に渡して生成しています。おそらくコマンドラインからマイグレーションファイルを生成する時にファイルストリームを使うのでしょう。

これで、$this->commands['migrate'] に MigrageCommand を生成するクロージャーが入っているのが推測されます。

一つ疑問があります。Symfony\Component\Console\Application::add() の中で以下の処理によって $this->commands[] にコマンドを登録していると思います。

$this->commands[$command->getName()] = $command;

この $command->getName() で取得するコマンド名が migrate の場合どこで定義しているのでしょうか。
Illuminate\Database\Console\Migrations\MigrateCommand クラスの定義を見てみましょう。

Illuminate\Database\Console\Migrations\MigrateCommand 抜粋

    use ConfirmableTrait;

    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'migrate {--database= : The database connection to use}
                {--force : Force the operation to run when in production}
                {--path=* : The path(s) to the migrations files to be executed}
                {--realpath : Indicate any provided migration file paths are pre-resolved absolute paths}
                {--pretend : Dump the SQL queries that would be run}
                {--seed : Indicates if the seed task should be re-run}
                {--step : Force the migrations to be run so they can be rolled back individually}';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Run the database migrations';

    /**
     * The migrator instance.
     *
     * @var \Illuminate\Database\Migrations\Migrator
     */
    protected $migrator;

    /**
     * Create a new migration command instance.
     *
     * @param  \Illuminate\Database\Migrations\Migrator  $migrator
     * @return void
     */
    public function __construct(Migrator $migrator)
    {
        parent::__construct();

        $this->migrator = $migrator;
    }

registerMigrateCommand() メソッドで MigrateCommand インスタンスを生成しています。MigrateCommand クラスは $signature 変数にコマンド名と署名が定義してあります。
MigrateCommand クラスのスーパークラスのスーパークラス、Illuminate\Console\Command のコンストラクタに以下のようなロジックが入っています。

Illuminate\Console\Command::__construct()

    /**
     * Create a new console command instance.
     *
     * @return void
     */
    public function __construct()
    {
        // We will go ahead and set the name, description, and parameters on console
        // commands just to make things a little easier on the developer. This is
        // so they don't have to all be manually specified in the constructors.
        if (isset($this->signature)) {
            $this->configureUsingFluentDefinition();
        } else {
            parent::__construct($this->name);
        }

        // Once we have constructed the command, we'll set the description and other
        // related properties of the command. If a signature wasn't used to build
        // the command we'll set the arguments and the options on this command.
        $this->setDescription((string) $this->description);

        $this->setHelp((string) $this->help);

        $this->setHidden($this->isHidden());

        if (! isset($this->signature)) {
            $this->specifyParameters();
        }
    }

    /**
     * Configure the console command using a fluent definition.
     *
     * @return void
     */
    protected function configureUsingFluentDefinition()
    {
        [$name, $arguments, $options] = Parser::parse($this->signature);

        parent::__construct($this->name = $name);

        // After parsing the signature we will spin through the arguments and options
        // and set them on this command. These will already be changed into proper
        // instances of these "InputArgument" and "InputOption" Symfony classes.
        $this->getDefinition()->addArguments($arguments);
        $this->getDefinition()->addOptions($options);
    }

$this->signature を検証し設定されていた場合、configureUsingFluentDefinition() メソッドがコールされます。configureUsingFluentDefinition() メソッドは Parser::parse($this->signature) の静的メソッドをコールして戻り値を $this->name に代入しています。
Parser::parse() を見てみましょう。

Illuminate\Console\Parser::parse()

    /**
     * Parse the given console command definition into an array.
     *
     * @param  string  $expression
     * @return array
     *
     * @throws \InvalidArgumentException
     */
    public static function parse($expression)
    {
        $name = static::name($expression);

        if (preg_match_all('/\{\s*(.*?)\s*\}/', $expression, $matches)) {
            if (count($matches[1])) {
                return array_merge([$name], static::parameters($matches[1]));
            }
        }

        return [$name, [], []];
    }
    /**
     * Extract the name of the command from the expression.
     *
     * @param  string  $expression
     * @return string
     *
     * @throws \InvalidArgumentException
     */
    protected static function name($expression)
    {
        if (! preg_match('/[^\s]+/', $expression, $matches)) {
            throw new InvalidArgumentException('Unable to determine command name from signature.');
        }

        return $matches[0];
    }

Illuminate\Console\Parser::parse()

受け取った引数のはじめからスペースまでの文字列をコマンド名に、パラメーターの説明として「{}」で囲まれた文字列を全て取得して配列型として戻されます。

これで $this->commands['migrate'] に MigrageCommand を生成するクロージャーが入っていることがはっきり確認できました。スッキリしましたね。
続きを読みましょう。

find() の続きにもどります。

$this->commands[] に登録されているコマンドに登録されているエイリアスで、$this->commands[] に登録されていないものを登録します。

has() メソッドで実行したいコマンドが登録されているか確認します。

Symfony\Component\Console\Application::has()

    /**
     * Returns true if the command exists, false otherwise.
     *
     * @return bool true if the command exists, false otherwise
     */
    public function has(string $name)
    {
        $this->init();

        return isset($this->commands[$name]) || ($this->commandLoader && $this->commandLoader->has($name) && $this->add($this->commandLoader->get($name)));
    }

Symfony\Component\Console\Application::has()

init() メソッドの後に $this->commands[$name] がセットされているか確認しています。今回はもちろん true が戻されます。
その後に書いてある commandLoader はなんでしょうか。コマンドアプリケーションの $commandLoader に代入されている CommandLoaderInterface インターフェースを実装したクラスのようです。

Symfony\Component\Console\CommandLoader\CommandLoaderInterface

interface CommandLoaderInterface
{
    /**
     * Loads a command.
     *
     * @return Command
     *
     * @throws CommandNotFoundException
     */
    public function get(string $name);

    /**
     * Checks if a command exists.
     *
     * @return bool
     */
    public function has(string $name);

    /**
     * @return string[] All registered command names
     */
    public function getNames();
}

$this->has() の返り値は true ですので、 $this->get() がコールされます。
見てみましょう。

Symfony\Component\Console\Application::get()

    /**
     * Returns a registered command by name or alias.
     *
     * @return Command A Command object
     *
     * @throws CommandNotFoundException When given command name does not exist
     */
    public function get(string $name)
    {
        $this->init();

        if (!$this->has($name)) {
            throw new CommandNotFoundException(sprintf('The command "%s" does not exist.', $name));
        }

        $command = $this->commands[$name];

        if ($this->wantHelps) {
            $this->wantHelps = false;

            $helpCommand = $this->get('help');
            $helpCommand->setCommand($command);

            return $helpCommand;
        }

        return $command;
    }

Symfony\Component\Console\Application::get()

まず初期化をします。そこら中に書いてありますね。そういう思想なのでしょう。
もし、渡されたコマンド名が登録されていなかった場合、「sprintf('The command "%s" does not exist.', $name)」とメッセージを添えて例外 CommandNotFoundException をスローします。
登録されていた場合、そのコマンドを取得して戻します。
ヘルプ表示フラグが立っていた場合はヘルプコマンドを優先して返します。

コマンドを受け取った find() メソッドはそれをそのまま返します。
今回のケースでは find() メソッドはここまで読めば良いのですが、
そのあとを少し覗いてみましょう。
いろいろ判定していますが、
「そんなコマンドはないけどもしかしてこれの事かい？」というようなメッセージをセットしていたりします。
コマンドが見つからなかった時の救済処置や例外などを色々書いているのでしょう。今回はこれ以上深追いしないことにします。

find() メソッドの中身はほぼ理解しました。続きを読みましょう。

その１１に続く。

The post 【フレームワークを読む】Laravelのマイグレーションファイルは何をしているのか？ ：その１０：Console\Application::find() appeared first on XIONCC.

例

$xion = 'xionxionxion';
echo($xion[0].PHP_EOL);
echo($xion[1].PHP_EOL);
echo($xion[2].PHP_EOL);
echo($xion[3].PHP_EOL);

出力結果

x
i
o
n

The post PHP ストリングに対する[] でのアクセス appeared first on XIONCC.