added custom migration generator artisan command

master
Garrett Mills 7 years ago
parent 78c8ebadc2
commit 95f5ba11df

@ -1,7 +1,5 @@
# Laravel Meta-Articles
[![Build Status][ico-build]][link-travis]
[![Quality Score][ico-scrutinizer]][link-scrutinizer]
[![Latest Unstable Version][ico-unstable]][link-packagist]
[![License][ico-license]][link-license]
[![Total Downloads][ico-downloads]][link-packagist]
@ -48,27 +46,17 @@ class Post extends Meta
> *Important*: do not extend the Model class, Meta does this for you
Then, include the 'meta' and 'uuid' columns in your database table:
The Meta plugin adds a custom Artisan command to auto-generate migrations for meta-enabled models.
To generate a migration for a new meta-model, use the following command:
In your migration,
``` php
<?php
```
php artisan meta:migration name_of_migration --create=table_name
```
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
Add your custom fields, if any, then migrate as usual:
use Glmdev\Meta\Meta;
class CreatePostsTable extends Migration
{
public function up()
{
Schema::create('posts', function (Blueprint $table) {
// all your table values
Meta::formTable($table);
});
}
}
```
php artisan migrate
```
Then, just create a model like usual:
@ -102,6 +90,50 @@ And to retrieve meta information, use the 'read' method.
$post->read('author'); //returns 'Bob Saget'
```
### Adding Meta functionality to existing models
To add Meta capabilities to existing models, you need to add the database columns and tweak the model's class as follows:
##### Database update
Create a new database migration using the custom Meta command:
```
php artisan meta:migration --table=existing_table_name
```
Make sure the inside of the `up()` function matches the following:
``` php
public function up()
{
Schema::table('DummyTable', function (Blueprint $table) {
Meta::formTable($table);
});
}
```
Then, migrate:
```
php artisan migrate
```
##### Model Class updates
To enable the database functionality, the class for the model needs to extend the Meta class. Modify the class header to the following format:
``` php
class ClassNameHere extends Meta {
// your class stuff here
}
```
> *Important*: you no longer need to extend the Model class, Meta does this for you
After that, you can use the full meta functionality with your model.
### Query Builder
Let's say you need to retrieve the post that has a certain UUID (maybe you gave it out in a url or something)

@ -19,6 +19,7 @@
"autoload": {
"psr-4": {
"Glmdev\\Meta\\": "src/",
"Glmdev\\Meta\\Commands\\": "src/Commands/",
"Glmdev\\Meta\\Tests\\": "tests/"
}
}

@ -0,0 +1,118 @@
<?php
namespace Glmdev\Meta\Commands;
use Illuminate\Database\Console\Migrations\MigrateMakeCommand as VanillaCommand;
use Glmdev\Meta\MetaMigrationCreator;
use \Illuminate\Support\Composer as Compsr;
class MetaMigrationCommand extends VanillaCommand {
/**
* The console command signature.
*
* @var string
*/
protected $signature = 'meta:migration {name : The name of the migration.}
{--create= : The table to be created.}
{--table= : The table to migrate.}
{--path= : The location where the migration file should be created.}';
/**
* The console command description.
*
* @var string
*/
protected $description = 'Create a new meta-enabled migration file';
/**
* The migration creator instance.
*
* @var \Glmdev\Meta\MetaMigrationCreator
*/
protected $creator;
/**
* The Composer instance.
*
* @var \Illuminate\Support\Composer
*/
protected $composer;
/**
* Create a new migration install command instance.
*
* @param \Glmdev\Meta\MigrationCreator $creator
* @param \Illuminate\Support\Composer $composer
* @return void
*/
public function __construct(MetaMigrationCreator $creator, Compsr $composer)
{
parent::__construct($creator, $composer);
$this->creator = $creator;
$this->composer = $composer;
}
/**
* Execute the console command.
*
* @return void
*/
public function fire()
{
// It's possible for the developer to specify the tables to modify in this
// schema operation. The developer may also specify if this table needs
// to be freshly created so we can create the appropriate migrations.
$name = trim($this->input->getArgument('name'));
$table = $this->input->getOption('table');
$create = $this->input->getOption('create') ?: false;
if (! $table && is_string($create)) {
$table = $create;
$create = true;
}
// Now we are ready to write the migration out to disk. Once we've written
// the migration out, we will dump-autoload for the entire framework to
// make sure that the migrations are registered by the class loaders.
$this->writeMigration($name, $table, $create);
$this->composer->dumpAutoloads();
}
/**
* Write the migration file to disk.
*
* @param string $name
* @param string $table
* @param bool $create
* @return string
*/
protected function writeMigration($name, $table, $create)
{
$path = $this->getMigrationPath();
$file = pathinfo($this->creator->create($name, $path, $table, $create), PATHINFO_FILENAME);
$this->line("<info>Created Migration:</info> {$file}");
}
/**
* Get migration path (either specified by '--path' option or default location).
*
* @return string
*/
protected function getMigrationPath()
{
if (! is_null($targetPath = $this->input->getOption('path'))) {
return $this->laravel->basePath().'/'.$targetPath;
}
return parent::getMigrationPath();
}
}

@ -0,0 +1,186 @@
<?php
namespace Glmdev\Meta;
use Closure;
use Illuminate\Support\Str;
use InvalidArgumentException;
use Illuminate\Filesystem\Filesystem;
class MetaMigrationCreator extends \Illuminate\Database\Migrations\MigrationCreator
{
/**
* Create a new migration creator instance.
*
* @param \Illuminate\Filesystem\Filesystem $files
* @return void
*/
public function __construct(Filesystem $files)
{
$this->files = $files;
}
/**
* Create a new migration at the given path.
*
* @param string $name
* @param string $path
* @param string $table
* @param bool $create
* @return string
* @throws \Exception
*/
public function create($name, $path, $table = null, $create = false)
{
$this->ensureMigrationDoesntAlreadyExist($name);
$path = $this->getPath($name, $path);
// First we will get the stub file for the migration, which serves as a type
// of template for the migration. Once we have those we will populate the
// various place-holders, save the file, and run the post create event.
$stub = $this->getStub($table, $create);
$this->files->put($path, $this->populateStub($name, $stub, $table));
$this->firePostCreateHooks();
return $path;
}
/**
* Ensure that a migration with the given name doesn't already exist.
*
* @param string $name
* @return void
*
* @throws \InvalidArgumentException
*/
protected function ensureMigrationDoesntAlreadyExist($name)
{
if (class_exists($className = $this->getClassName($name))) {
throw new InvalidArgumentException("A $className migration already exists.");
}
}
/**
* Get the migration stub file.
*
* @param string $table
* @param bool $create
* @return string
*/
protected function getStub($table, $create)
{
if (is_null($table)) {
return $this->files->get($this->getStubPath().'/migration.stub');
}
// We also have stubs for creating new tables and modifying existing tables
// to save the developer some typing when they are creating a new tables
// or modifying existing tables. We'll grab the appropriate stub here.
else {
$stub = $create ? 'create.stub' : 'update.stub';
return $this->files->get($this->getStubPath()."/{$stub}");
}
}
/**
* Populate the place-holders in the migration stub.
*
* @param string $name
* @param string $stub
* @param string $table
* @return string
*/
protected function populateStub($name, $stub, $table)
{
$stub = str_replace('DummyClass', $this->getClassName($name), $stub);
// Here we will replace the table place-holders with the table specified by
// the developer, which is useful for quickly creating a tables creation
// or update migration from the console instead of typing it manually.
if (! is_null($table)) {
$stub = str_replace('DummyTable', $table, $stub);
}
return $stub;
}
/**
* Get the class name of a migration name.
*
* @param string $name
* @return string
*/
protected function getClassName($name)
{
return Str::studly($name);
}
/**
* Fire the registered post create hooks.
*
* @return void
*/
protected function firePostCreateHooks()
{
foreach ($this->postCreate as $callback) {
call_user_func($callback);
}
}
/**
* Register a post migration create hook.
*
* @param \Closure $callback
* @return void
*/
public function afterCreate(Closure $callback)
{
$this->postCreate[] = $callback;
}
/**
* Get the full path name to the migration.
*
* @param string $name
* @param string $path
* @return string
*/
protected function getPath($name, $path)
{
return $path.'/'.$this->getDatePrefix().'_'.$name.'.php';
}
/**
* Get the date prefix for the migration.
*
* @return string
*/
protected function getDatePrefix()
{
return date('Y_m_d_His');
}
/**
* Get the path to the stubs.
*
* @return string
*/
public function getStubPath()
{
return __DIR__.'/stubs';
}
/**
* Get the filesystem instance.
*
* @return \Illuminate\Filesystem\Filesystem
*/
public function getFilesystem()
{
return $this->files;
}
}

@ -12,7 +12,15 @@ class MetaServiceProvider extends ServiceProvider
*
* @var bool
*/
protected $defer = true;
protected $defer = false;
protected $commands = [
'\Glmdev\Meta\Commands\MetaMigrationCommand',
];
public function boot(){
}
/**
* Register any package services.
@ -21,9 +29,16 @@ class MetaServiceProvider extends ServiceProvider
*/
public function register()
{
// die('gtest2');
$loader = \Illuminate\Foundation\AliasLoader::getInstance();
$loader->alias('Meta', 'Glmdev\Meta\Meta');
$this->commands($this->commands);
}
public static function hello(){return "Hello!";}
}

@ -0,0 +1,34 @@
<?php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
use Glmdev\Meta\Meta;
class DummyClass extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('DummyTable', function (Blueprint $table) {
$table->increments('id');
$table->timestamps();
Meta::formTable($table);
});
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::dropIfExists('DummyTable');
}
}

@ -0,0 +1,29 @@
<?php
use Glmdev\Meta\Meta;
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
class DummyClass extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
//
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
//
}
}

@ -0,0 +1,33 @@
<?php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
use Glmdev\Meta\Meta;
class DummyClass extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::table('DummyTable', function (Blueprint $table) {
Meta::formTable($table);
});
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::table('DummyTable', function (Blueprint $table) {
//
});
}
}

@ -0,0 +1,33 @@
<?php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
use Glmdev\Meta\Meta;
class DummyClass extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::table('DummyTable', function (Blueprint $table) {
//
});
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::table('DummyTable', function (Blueprint $table) {
//
});
}
}
Loading…
Cancel
Save