added custom migration generator artisan command

README.md

@@ -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 artisan meta:migration name_of_migration --create=table_name
-<?php
+```
 
-use Illuminate\Database\Schema\Blueprint;
+Add your custom fields, if any, then migrate as usual:
-use Illuminate\Database\Migrations\Migration;
 
-use Glmdev\Meta\Meta;
+```
-
+php artisan migrate
-class CreatePostsTable extends Migration
-{
-    public function up()
-    {
-        Schema::create('posts', function (Blueprint $table) {
-            // all your table values
-            Meta::formTable($table);
-        });
-    }
-}
 ```
 
 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)

composer.json

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

src/Commands/MetaMigrationCommand.php

@@ -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();
+    }
+    
+}

src/MetaMigrationCreator.php

@@ -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;
+    }
+}

src/MetaServiceProvider.php

@@ -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!";}
 }

src/stubs/create.stub

@@ -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');
+    }
+}

src/stubs/migration.stub

@@ -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()
+    {
+        //
+    }
+}

src/stubs/regen.stub

@@ -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) {
+            //
+        });
+    }
+}

src/stubs/update.stub

@@ -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) {
+            //
+        });
+    }
+}