Make facade for interface possible

Fixes #36

composer.json

@@ -11,11 +11,11 @@
     ],
     "require": {
         "php": ">=5.3.0",
-        "illuminate/support": "4.0.x",
+        "illuminate/support": "4.x",
-        "illuminate/console": "4.0.x",
+        "illuminate/console": "4.x",
-        "illuminate/filesystem": "4.0.x",
+        "illuminate/filesystem": "4.x",
-        "phpdocumentor/reflection-docblock": "dev-master#6d705c1a0f9e2a6d73d2e9ec0e538b9dfaf4315f",
+        "phpdocumentor/reflection-docblock": "2.0.0",
-        "symfony/class-loader": "2.3.*"
+        "symfony/class-loader": "~2.3"
     },
     "autoload": {
         "psr-0": {

readme.md

@@ -1,19 +1,22 @@
-## Laravel IDE Helper & Generator
+## Laravel IDE Helper Generator
+[![Latest Stable Version](https://poser.pugx.org/barryvdh/laravel-ide-helper/version.png)](https://packagist.org/packages/barryvdh/laravel-ide-helper) [![Total Downloads](https://poser.pugx.org/barryvdh/laravel-ide-helper/d/total.png)](https://packagist.org/packages/barryvdh/laravel-ide-helper)
 
 ### Complete phpDocs, directly from the source
 
-Add the helper file to your laravel folder (not in a public folder). The file isn't used by Laravel, but it has to be indexed by your IDE.
+This packages generates a file that your IDE can understand, so it can provide accurate autocompletion. Generation is done, based on the files in your project, so they are alway up-to-date.
+If you don't want to generate it, you can add a pre-generated file to the root folder of your laravel project. (But this isn't as up-to-date as self generated files)
 
-* Netbeans and PHPStorm version: https://gist.github.com/barryvdh/5227822
+* Generated version: https://gist.github.com/barryvdh/5227822
-* SublimeText CodeIntel version: https://gist.github.com/barryvdh/5227814
+
+Note: You do need CodeIntel for Sublime Text: https://github.com/SublimeCodeIntel/SublimeCodeIntel
 
 ### Automatic phpDoc generation for Laravel Facades
 
-Require this package in your composer.json:
+Require this package in your composer.json and run composer update (or run `composer require barryvdh/laravel-ide-helper:1.*` directly):
 
     "barryvdh/laravel-ide-helper": "1.*"
 
-And add the ServiceProvider to the providers array in app/config/app.php
+After updating composer, add the ServiceProvider to the providers array in app/config/app.php
 
     'Barryvdh\LaravelIdeHelper\IdeHelperServiceProvider',
 
@@ -21,18 +24,14 @@ You can now re-generate the docs yourself (for future updates) in artisan
 
     php artisan ide-helper:generate
 
-If you use SublimeText CodeIntel, the format is a bit different. So add --sublime (or -S) to your command
+Note: bootstrap/compiled.php has to be cleared first, so run `php artisan clear-compiled` before generating (and `php artisan optimize` after..)
-
-    php artisan ide-helper:generate -S
-
-Note: You do need CodeIntel for Sublime Text: https://github.com/Kronuz/SublimeCodeIntel
 
 You can configure your composer.json to do this after each commit:
 
     "scripts":{
         "post-update-cmd":[
-            "php artisan optimize",
             "php artisan ide-helper:generate",
+            "php artisan optimize",
         ]
     },
 
@@ -49,23 +48,39 @@ You can choose to include helper files. This is not enabled by default, but you
 The Illuminate/Support/helpers.php is already set-up, but you can add/remove your own files in the config file.
 
 
-### Work in progress: Model docs
+### Automatic phpDocs for Models
 
-If you don't want to write your properties yourself, you can use the (experimental) command `ide-helper:models` to generate
+If you don't want to write your properties yourself, you can use the command `ide-helper:models` to generate
-phpDocs, based on table columns, relations and getters/setters. Very alpha, so please provide feedback if you want.
+phpDocs, based on table columns, relations and getters/setters. Still in beta, so please provide feedback if you want.
-Docs are written to a phpfile in the root of the project, so you can move the docs to the real model.
+You can now also write the comments directly to your Model file, using the `--write (-W)` option. By default, you are asked to overwrite or
+write to a seperate file (_ide_helper_models.php) Please make sure to backup your models, before writing the info.
+It should keep the existing comments and only append new properties/methods. The existing phpdoc is replaced, or added if not found.
+With the `--reset (-R)` option, the existing phpdocs are ignored, only the newly found columns/relations are saved as phpdocs.
 
-For now, only models in app/models are scanned. The optional argument tells what models to use.
+    php artisan ide-helper:models Post
-`php artisan ide-helper:models Post,User`
 
-Note: With namespaces, uses \\ instead of \
+    /**
-`php artisan ide-helper:models API\\User`
+     * An Eloquent Model: 'Post'
+     *
+     * @property integer $id
+     * @property integer $author_id
+     * @property string $title
+     * @property string $text
+     * @property \Carbon\Carbon $created_at
+     * @property \Carbon\Carbon $updated_at
+     * @property-read \User $author
+     * @property-read \Illuminate\Database\Eloquent\Collection|\Comment[] $comments
+     */
 
-This creates a file with the phpDocs for each Model. You should check and change them to be more accurate.
+By default, models in app/models are scanned. The optional argument tells what models to use (also outside app/models).
-It doesn't know if datetimes are returned as string or DateTime/Carbon, but I assume they are.
-Also, all relations are Eloquent|Eloquent[] by default, you can change them to the actual Model.
-After copying the phpdocs to your model, you can clear the file, so your IDE only uses the real source.
 
+    php artisan ide-helper:models Post,User
+
+You can also scan a different directory, using the --dir option (relative from the base path):
+
+    php artisan ide-helper:models --dir="app/workbench/name/package/models"
+
+Note: With namespaces, wrap your model name in " signs: `php artisan ide-helper:models "API\User"`, or escape the slashes (`Api\\User`)
 
 ### License
 

src/Barryvdh/LaravelIdeHelper/GeneratorCommand.php

@@ -39,10 +39,9 @@ class GeneratorCommand extends Command {
     protected $description = 'Generate a new IDE Helper file.';
 
     protected $extra;
-    protected $nonstatic;
     protected $onlyExtend;
     protected $helpers;
-    protected $sublime;
+    protected $magic;
 
 
     /**
@@ -52,34 +51,34 @@ class GeneratorCommand extends Command {
      */
     public function fire()
     {
-        $filename = $this->argument('filename');
+        if (file_exists($compiled = base_path().'/bootstrap/compiled.php')){
-
+            $this->error('Error generating IDE Helper: first delete bootstrap/compiled.php (php artisan clear-compiled)');
-        if($this->option('memory')){
-            $this->useMemoryDriver();
-        }
-
-        $this->extra = \Config::get('laravel-ide-helper::extra');
-        $this->nonstatic = \Config::get('laravel-ide-helper::nonstatic');
-        $this->onlyExtend = \Config::get('laravel-ide-helper::only_extend');
-
-        if( $this->option('helpers') || (\Config::get('laravel-ide-helper::include_helpers') && ! $this->option('nohelpers'))){
-            $this->helpers = \Config::get('laravel-ide-helper::helper_files');
         }else{
-            $this->helpers = array();
+            $filename = $this->argument('filename');
+    
+            if($this->option('memory')){
+                $this->useMemoryDriver();
+            }
+    
+            $this->extra = \Config::get('laravel-ide-helper::extra');
+            $this->magic = \Config::get('laravel-ide-helper::magic');
+
+            if( $this->option('helpers') || (\Config::get('laravel-ide-helper::include_helpers') )){
+                $this->helpers = \Config::get('laravel-ide-helper::helper_files');
+            }else{
+                $this->helpers = array();
+            }
+
+            $content = $this->generateDocs();
+    
+            $written = \File::put($filename, $content);
+    
+            if($written !== false){
+                $this->info("A new helper file was written to $filename");
+            }else{
+                $this->error("The helper file could not be created at $filename");
+            }
         }    
-
-        $this->sublime = $this->option('sublime') || \Config::get('laravel-ide-helper::sublime');
-
-        $content = $this->generateDocs();
-
-        $written = \File::put($filename, $content);
-
-        if($written !== false){
-            $this->info("A new helper file was written to $filename");
-        }else{
-            $this->error("The helper file could not be created at $filename");
-        }
-
     }
 
     protected function useMemoryDriver(){
@@ -113,7 +112,7 @@ class GeneratorCommand extends Command {
         return array(
             array('helpers', "H", InputOption::VALUE_NONE, 'Include the helper files'),
             array('memory', "M", InputOption::VALUE_NONE, 'Use sqlite memory driver'),
-            array('sublime', "S", InputOption::VALUE_NONE, 'Use different style for SublimeText CodeIntel'),
+            array('sublime', "S", InputOption::VALUE_NONE, 'DEPRECATED: Use different style for SublimeText CodeIntel'),
         );
     }
 
@@ -133,103 +132,53 @@ class GeneratorCommand extends Command {
  *
  * @author Barry vd. Heuvel <[email protected]>
  */
-namespace {\n\tdie('Only to be used as an helper for your IDE');\n}\n\n";
+exit('Only to be used as an helper for your IDE');\n\n";
 
+        //Get all aliases
         $aliases = $aliasLoader->getAliases();
 
         foreach($aliases as $alias => $facade){
 
-            try{
+            $root = $this->getRoot($facade);
-                if(method_exists($facade, 'getFacadeRoot')){
+            if(!$root){
-                    $root = get_class($facade::getFacadeRoot());
-                }else{
-                    $root = $facade;
-                }
-
-                if(!class_exists($root) && !interface_exists($root)){
-                    $this->error("Class $root is not found.");
-                    continue;
-                }
-            }catch(\PDOException $e){
-                $this->error("PDOException: ".$e->getMessage()."\nPlease configure your database connection correctly, or use the sqlite memory driver (-M). Skipping $facade.");
-                continue;
-            }catch(\Exception $e){
-                $this->error("Exception: ".$e->getMessage()."\nSkipping $facade.");
                 continue;
             }
 
-            if(strpos($alias, '\\') !== false){
-                $parts = explode('\\', $alias);
-                $alias = array_pop($parts);
-                $namespace = implode($parts, '\\');
-            }else{
-                $namespace = '';
-            }
-
             try{
-                $reflection = new \ReflectionClass($root);
 
-                $output .= "namespace $namespace {\n";
+                //Some classes extend the facade
-
+                if(interface_exists($facade)){
-                if($root !== $facade or in_array($alias, $this->onlyExtend)){
+                    $output .= "interface $alias extends $facade{\n";
-                    //If the root class is not the same as the facade extend it.
+                }elseif(class_exists($facade)){
-                    $output .= " class $alias extends $facade{\n";
+                    $output .= "class $alias extends $facade{\n";
                 }else{
-                    $output .= " class $alias{\n";
+                    $output .= "class $alias{\n";
                 }
-                $output .= "\t/**\n\t * @var \\$root \$root\n\t */\n\t static private \$root;\n\n";
 
-                if(!in_array($alias, $this->onlyExtend))
+                $usedMethods = array();
-                {
+
-                    $usedMethods = array();
+                //Only add the methods to the output when the root is not the same as the facade.
-                    if(array_key_exists($alias, $this->nonstatic) ){
+                $addOutput = ($root !== $facade);
-                        $nonstaticMethods = $this->nonstatic[$alias];
+                $output .= $this->getMethods($root, $alias, $usedMethods, $addOutput);
-                    }else{
-                        $nonstaticMethods = array();
-                    }
 
 
-                    $methods = $reflection->getMethods(\ReflectionMethod::IS_PUBLIC);
+                $driver =  $this->getDriver($alias);
-                    if($methods)
+                if($driver){
-                    {
+                    $output .= $this->getMethods($driver, $alias, $usedMethods);
-                        foreach ($methods as $method)
-                        {
-                            if(!in_array($method->name, $usedMethods)){
-                                $static = !in_array($method->name, $nonstaticMethods);
-                                $output .= $this->parseMethod($method, $alias, $root, $static);
-                                $usedMethods[] = $method->name;
-                            }
-                        }
-                    }
-
-                    if(array_key_exists($alias, $this->extra)){
-                        $i = 2;
-                        foreach($this->extra[$alias] as $extraClass){
-                            if(!class_exists($extraClass) && !interface_exists($extraClass)){
-                                continue;
-                            }
-                            $reflection = new \ReflectionClass($extraClass);
-
-                            $methods = $reflection->getMethods(\ReflectionMethod::IS_PUBLIC);
-                            if($methods)
-                            {
-                                $rootParam = "root".$i++;
-                                $output .= "\t/**\n\t * @var \\$extraClass \$$rootParam\n\t */\n\t static private \$$rootParam;\n\n";
-                                foreach ($methods as $method)
-                                {
-                                    if(!in_array($method->name, $usedMethods)){
-                                        $static = !in_array($method->name, $nonstaticMethods);
-                                        $output .= $this->parseMethod($method, $alias, $extraClass, $static, $rootParam);
-                                        $usedMethods[] = $method->name;
-                                    }
-
-                                }
-                            }
-
-                        }
-                    }
                 }
-                $output .= " }\n}\n\n";
+
+                //Add extra methods, from other classes (magic static calls)
+                if(array_key_exists($alias, $this->extra)){
+                    $output .= $this->getMethods($this->extra[$alias], $alias, $usedMethods);
+                }
+
+                //Add extra methods, from other classes (magic static calls)
+                if(array_key_exists($alias, $this->magic)){
+                    $output .= $this->addMagicMethods($this->magic[$alias], $alias, $usedMethods);
+                }
+
+
+                $output .= "}\n\n";
 
             }catch(\Exception $e){
                 $this->error("Exception: ".$e->getMessage()."\nCould not analyze $root.");
@@ -237,8 +186,9 @@ namespace {\n\tdie('Only to be used as an helper for your IDE');\n}\n\n";
 
         }
 
-        if(!empty($helpers)){
+        //Include the helper file, if requested
-            foreach($helpers as $helper){
+        if(!empty($this->helpers)){
+            foreach($this->helpers as $helper){
                 if (file_exists($helper)){
                     $output .= str_replace(array('<?php', '?>'), '', \File::get($helper));
                 }
@@ -249,26 +199,201 @@ namespace {\n\tdie('Only to be used as an helper for your IDE');\n}\n\n";
     }
 
     /**
-     * @param \ReflectionMethod $method
+     * Get the real root of a facade
-     * @param string $alias
+     *
-     * @param string $root
+     * @param $facade
-     * @param bool $static
+     * @return bool|string
-     * @param string $rootParam
+     */
+    protected function getRoot($facade){
+        try{
+            //If possible, get the facade root
+            if(method_exists($facade, 'getFacadeRoot')){
+                $root = get_class($facade::getFacadeRoot());
+            }else{
+                $root = $facade;
+            }
+
+            //If it doesn't exist, skip it
+            if(!class_exists($root) && !interface_exists($root)){
+                $this->error("Class $root is not found.");
+                return false;
+            }
+
+            return $root;
+
+            //When the database connection is not set, some classes will be skipped
+        }catch(\PDOException $e){
+            $this->error("PDOException: ".$e->getMessage()."\nPlease configure your database connection correctly, or use the sqlite memory driver (-M). Skipping $facade.");
+            return false;
+        }catch(\Exception $e){
+            $this->error("Exception: ".$e->getMessage()."\nSkipping $facade.");
+            return false;
+        }
+
+    }
+
+    public function getDriver($alias){
+        try{
+            if($alias == "Auth"){
+                $driver = \Auth::driver();
+            }elseif($alias == "DB"){
+                $driver = \DB::connection();
+            }elseif($alias == "Cache"){
+                $driver = \Cache::driver();
+            }elseif($alias == "Queue"){
+                $driver = \Queue::connection();
+            }else{
+                return false;
+            }
+
+            return get_class($driver);
+        }catch(\Exception $e){
+            $this->error("Could not determine driver/connection for $alias.");
+            return false;
+        }
+    }
+
+    /**
+     * Get the methods for one or multiple classes.
+     *
+     * @param $classes
+     * @param $alias
+     * @param $usedMethods
+     * @param bool $addOutput
      * @return string
      */
-    protected function parseMethod($method, $alias, $root, $static = true, $rootParam = 'root'){
+    protected function getMethods($classes, $alias, &$usedMethods, $addOutput = true){
+        if(!is_array($classes)){
+            $classes = array($classes);
+        }
         $output = '';
+        foreach($classes as $class){
+            if(!class_exists($class) && !interface_exists($class)){
+                continue;
+            }
+            $reflection = new \ReflectionClass($class);
+
+            $methods = $reflection->getMethods(\ReflectionMethod::IS_PUBLIC);
+            if($methods)
+            {
+                foreach ($methods as $method)
+                {
+                    if(!in_array($method->name, $usedMethods)){
+                        if( $addOutput){
+                            $output .= $this->parseMethod($method, $alias, $reflection);
+                        }
+                        $usedMethods[] = $method->name;
+                    }
+                }
+            }
+        }
+        return $output;
+    }
+
+    /**
+     * Get the methods for one or multiple magic methods.
+     *
+     * @param $methods
+     * @param $alias
+     * @param $usedMethods
+     * @param bool $addOutput
+     * @return string
+     */
+    protected function addMagicMethods($methods, $alias, &$usedMethods, $addOutput = true){
+        $output = '';
+        foreach($methods as $magic => $real){
+            list($className, $name) = explode('::', $real);
+            if(!class_exists($className) && !interface_exists($className)){
+                continue;
+            }
+            $method = new \ReflectionMethod($className, $name);
+            $class = new \ReflectionClass($className);
+
+            if(!in_array($method->name, $usedMethods)){
+                if( $addOutput){
+                    $output .= $this->parseMethod($method, $alias, $class, $magic);
+                }
+                $usedMethods[] = $method->name;
+            }
+
+
+            $usedMethods[] = $magic;
+
+        }
+        return $output;
+    }
+
+    /**
+     * @param \ReflectionMethod $method
+     * @param string $alias
+     * @param $class
+     * @param null $methodName
+     * @return string
+     */
+    protected function parseMethod($method, $alias, $class, $methodName = null){
+        $output = '';
+
+        // Don't add the __clone() functions
         if($method->name === '__clone'){
             return $output;
         }
+        $methodName = $methodName ?: $method->name;
 
         $namespace = $method->getDeclaringClass()->getNamespaceName();
 
+        //Create a DocBlock and serializer instance
         $phpdoc = new DocBlock($method, new Context($namespace));
         $serializer = new DocBlockSerializer(1, "\t");
 
+        //Normalize the description and inherit the docs from parents/interfaces
+        $this->normalizeDescription($phpdoc, $method);
+
+        //Correct the return values
+        $returnValue = $this->getReturn($phpdoc);
+
+        //Get the parameters, including formatted default values
+        list($params, $paramsWithDefault) = $this->getParameters($method);
+
+        //Make the method static
+        $phpdoc->appendTag(Tag::createInstance('@static', $phpdoc));
+
+        //Write the output, using the DocBlock serializer
+        $output .= $serializer->getDocComment($phpdoc) ."\n\t public static function ".$methodName."(";
+
+        $output .= implode($paramsWithDefault, ", ");
+        $output .= "){\r\n";
+
+        //Only return when not a constructor and not void.
+        $return = ($returnValue && $returnValue !== "void" && $method->name !== "__construct") ? 'return' : '';
+
+        //Reference the 'real' function in the declaringclass
+        $declaringClass = $method->getDeclaringClass();
+        $root = $class->getName();
+
+        if($declaringClass->name != $root){
+            $output .= "\t\t//Method inherited from $declaringClass->name\r\n";
+        }
+
+        $output .=  "\t\t$return $root::";
+
+        //Write the default parameters in the function call
+        $output .=  $method->name."(".implode($params, ", ").");\r\n";
+        $output .= "\t }\n\n";
+
+        return $output;
+    }
+
+    /**
+     * Get the description and get the inherited docs.
+     *
+     * @param $phpdoc
+     * @param $method
+     */
+    protected function normalizeDescription(&$phpdoc, $method){
+        //Get the short + long description from the DocBlock
         $description = $phpdoc->getText();
 
+        //Loop through parents/interfaces, to fill in {@inheritdoc}
         if(strpos($description, '{@inheritdoc}') !== false){
             $inheritdoc = $this->getInheritDoc($method);
             $inheritDescription = $inheritdoc->getText();
@@ -276,6 +401,7 @@ namespace {\n\tdie('Only to be used as an helper for your IDE');\n}\n\n";
             $description = str_replace('{@inheritdoc}', $inheritDescription, $description);
             $phpdoc->setText($description);
 
+            //Add the tags that are inherited
             $inheritTags = $inheritdoc->getTags();
             if($inheritTags){
                 foreach($inheritTags as $tag){
@@ -284,45 +410,35 @@ namespace {\n\tdie('Only to be used as an helper for your IDE');\n}\n\n";
                 }
             }
         }
+    }
 
-        $phpdoc->appendTag(Tag::createInstance('@static', $phpdoc));
+    /**
-
+     * Make some changes to the return types, if needed.
-        //Looping through the parameters and re-setting the type, to get the expanded type (with namespace)
+     *
-        //Should be fixed in a future version of ReflectionDocBlock I hope..
+     * @param $phpdoc
-        $paramTags = $phpdoc->getTagsByName('param');
+     * @return string|null
-        if($paramTags){
+     */
-            /** @var  $tag */
+    protected function getReturn($phpdoc){
-            foreach($paramTags as $tag){
+        //Get the return type and adjust them for beter autocomplete
-                $content = $tag->getContent();
-                //Closure should be \Closure..
-                $content = str_replace('\Closure', 'Closure', $content);
-                $content = str_replace('Closure', '\Closure', $content);
-                $tag->setContent($content);
-                $tag->setContent($tag->getType() . ' ' . $tag->getVariableName() . ' ' . $tag->getDescription());
-            }
-        }
-
         $returnTags = $phpdoc->getTagsByName('return');
         if($returnTags){
             /** @var  $tag */
             $tag = reset($returnTags);
             $returnValue = $tag->getType();
-
-            if(!$this->sublime and $alias == 'Eloquent' and
-                (in_array($method->name, array('pluck', 'first', 'fill', 'newInstance', 'newFromBuilder', 'create', 'find', 'findOrFail'))
-                    or $returnValue === '\Illuminate\Database\Query\Builder')){
-                //Reference the calling class, to provide more accurate auto-complete
-                $returnValue = "static";
-            }elseif(!$this->sublime and $alias == 'Eloquent' and in_array($method->name, array('all', 'get'))){
-                $returnValue .= "|\Eloquent[]|static[]";
-            }
-           $tag->setContent($returnValue . " ". $tag->getDescription());
         }else{
             $returnValue = null;
         }
+        return $returnValue;
+    }
 
-        $output .= $serializer->getDocComment($phpdoc) ."\n\t public ".($static ? 'static' : '')." function ".$method->name."(";
+    /**
-
+     * Get the parameters and format them correctly
+     *
+     * @param $method
+     * @return array
+     */
+    public function getParameters($method){
+        //Loop through the default values for paremeters, and make the correct output string
         $params = array();
         $paramsWithDefault = array();
         foreach ($method->getParameters() as $param) {
@@ -345,21 +461,7 @@ namespace {\n\tdie('Only to be used as an helper for your IDE');\n}\n\n";
             }
             $paramsWithDefault[] = $paramStr;
         }
-        $output .= implode($paramsWithDefault, ", ");
+        return array($params, $paramsWithDefault);
-        $output .= "){\r\n";
-
-        $return = ($returnValue && $returnValue !== "void") ? 'return' : '';
-
-        if($this->sublime){
-            $output .= "\t\t\$$rootParam = new $root();\r\n";
-            $output .=  "\t\t$return \$$rootParam->";
-        }else{
-            $output .=  "\t\t$return static::\$$rootParam->";
-        }
-        $output .=  $method->name."(".implode($params, ", ").");\r\n";
-        $output .= "\t }\n\n";
-
-        return $output;
     }
 
     /**
@@ -369,6 +471,7 @@ namespace {\n\tdie('Only to be used as an helper for your IDE');\n}\n\n";
     protected function getInheritDoc($reflectionMethod){
         $parentClass = $reflectionMethod->getDeclaringClass()->getParentClass();
 
+        //Get either a parent or the interface
         if($parentClass){
             $method = $parentClass->getMethod($reflectionMethod->getName());
         }else{

src/Barryvdh/LaravelIdeHelper/IdeHelperServiceProvider.php

@@ -19,7 +19,7 @@ class IdeHelperServiceProvider extends ServiceProvider {
 	 *
 	 * @var bool
 	 */
-	protected $defer = false;
+	protected $defer = true;
 
 	/**
 	 * Bootstrap the application events.

src/Barryvdh/LaravelIdeHelper/ModelsCommand.php

@@ -13,6 +13,10 @@ use Illuminate\Console\Command;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\ClassLoader\ClassMapGenerator;
+use phpDocumentor\Reflection\DocBlock;
+use phpDocumentor\Reflection\DocBlock\Context;
+use phpDocumentor\Reflection\DocBlock\Tag;
+use phpDocumentor\Reflection\DocBlock\Serializer as DocBlockSerializer;
 /**
  * A command to generate autocomplete information for your IDE
  *
@@ -26,6 +30,7 @@ class ModelsCommand extends Command {
      * @var string
      */
     protected $name = 'ide-helper:models';
+    protected $filename = '_ide_helper_models.php';
 
     /**
      * The console command description.
@@ -36,6 +41,10 @@ class ModelsCommand extends Command {
 
     protected $properties = array();
     protected $methods = array();
+    protected $write = false;
+    protected $dir;
+    protected $reset;
+
 
 
     /**
@@ -46,18 +55,29 @@ class ModelsCommand extends Command {
     public function fire()
     {
         $filename = $this->option('filename');
+        $this->write = $this->option('write');
+        $this->dir = $this->option('dir');
         $model = $this->argument('model');
+        $ignore = $this->option('ignore');
+        $this->reset = $this->option('reset');
 
-        $content = $this->generateDocs($model);
+        //If filename is default and Write is not specified, ask what to do
-
+        if(!$this->write && $filename === $this->filename && !$this->option('nowrite')){
-        $written = \File::put($filename, $content);
+            if($this->confirm("Do you want to overwrite the existing model files for '$model'? Choose no to write to $filename instead? (Yes/No): ")){
-
+                $this->write = true;
-        if($written !== false){
+            }
-            $this->info("Model information was written to $filename");
-        }else{
-            $this->error("Failed to write model information to $filename");
         }
 
+        $content = $this->generateDocs($model, $ignore);
+
+        if(!$this->write){
+            $written = \File::put($filename, $content);
+            if($written !== false){
+                $this->info("Model information was written to $filename");
+            }else{
+                $this->error("Failed to write model information to $filename");
+            }
+        }
     }
 
 
@@ -70,7 +90,6 @@ class ModelsCommand extends Command {
     {
         return array(
             array('model', InputArgument::OPTIONAL, 'Which models to include', '*'),
-
         );
     }
 
@@ -82,11 +101,16 @@ class ModelsCommand extends Command {
     protected function getOptions()
     {
         return array(
-            array('filename', 'F', InputOption::VALUE_OPTIONAL, 'The path to the helper file', '_ide_helper_models.php'),
+            array('filename', 'F', InputOption::VALUE_OPTIONAL, 'The path to the helper file', $this->filename),
+            array('dir', 'D', InputOption::VALUE_OPTIONAL, 'The model dir','app/models'),
+            array('write', 'W', InputOption::VALUE_NONE, 'Write to Model file'),
+            array('nowrite', 'N', InputOption::VALUE_NONE, 'Don\'t write to Model file'),
+            array('reset', 'R', InputOption::VALUE_NONE, 'Remove the original phpdocs instead of appending'),
+            array('ignore', 'I', InputOption::VALUE_OPTIONAL, 'Which models to ignore', ''),
         );
     }
 
-    protected function generateDocs($model){
+    protected function generateDocs($model, $ignore = ''){
 
 
         $output = "<?php
@@ -105,7 +129,15 @@ class ModelsCommand extends Command {
             $models = explode(',', $model);
         }
 
+        $ignore = explode(',', $ignore);
+
         foreach($models as $name){
+            if(in_array($name, $ignore)){
+                $this->comment("Ignoring model '$name'");
+                continue;
+            }else{
+                $this->comment("Loading model '$name'");
+            }
             $this->properties = array();
             $this->methods = array();
             if(class_exists($name)){
@@ -129,24 +161,33 @@ class ModelsCommand extends Command {
 
 
     protected function loadModels(){
+        $dir = base_path().'/'.$this->dir;
         $models = array();
-        foreach(ClassMapGenerator::createMap(app_path().'/models') as $model=> $path){
+        if(file_exists($dir)){
-            $models[] = $model;
+            foreach(ClassMapGenerator::createMap($dir) as $model=> $path){
+                $models[] = $model;
+            }
         }
         return $models;
     }
 
+    /**
+     * Load the properties from the database table.
+     *
+     * @param \Illuminate\Database\Eloquent\Model $model
+     */
     protected function getPropertiesFromTable($model){
         $table = $model->getTable();
         $schema = $model->getConnection()->getDoctrineSchemaManager($table);
+        $schema->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string');
 
         $columns = $schema->listTableColumns($table);
 
-        $properties = array();
         if($columns){
             foreach ($columns as $column) {
                 $name = $column->getName();
                 $type =  $column->getType()->getName();
+
                 switch($type){
                     case 'string':
                     case 'text':
@@ -180,6 +221,9 @@ class ModelsCommand extends Command {
         }
     }
 
+    /**
+     * @param \Illuminate\Database\Eloquent\Model $model
+     */
     protected function getPropertiesFromMethods($model){
         $methods = get_class_methods($model);
         if($methods){
@@ -198,9 +242,13 @@ class ModelsCommand extends Command {
                    }
                }elseif(\Str::startsWith($method, 'scope') && $method !== 'scopeQuery'){
                    //Magic set<name>Attribute
-                   $name =  \Str::snake(substr($method, 5));
+                   $name =  \Str::camel(substr($method, 5));
                    if(!empty($name)){
-                       $this->setMethod($name, 'static');
+                       $reflection = new \ReflectionMethod($model, $method);
+                       $args = $this->getParameters($reflection);
+                       //Remove the first ($query) argument
+                       array_shift($args);
+                       $this->setMethod($name, $reflection->class, $args);
                    }
                }elseif(!method_exists('Eloquent', $method) && !\Str::startsWith($method, 'get')){
 
@@ -242,6 +290,12 @@ class ModelsCommand extends Command {
         }
     }
 
+    /**
+     * @param string $name
+     * @param string|null $type
+     * @param bool|null $read
+     * @param bool|null $write
+     */
     protected function setProperty($name, $type = null, $read = null, $write = null){
         if(!isset($this->properties[$name])){
             $this->properties[$name] = array();
@@ -260,28 +314,51 @@ class ModelsCommand extends Command {
         }
     }
 
-    protected function setMethod($name, $type = null){
+    protected function setMethod($name, $type = '', $arguments=array()){
         if(!isset($this->methods[$name])){
             $this->methods[$name] = array();
-            $this->methods[$name]['type'] = 'static';
-        }
-        if($type !== null){
             $this->methods[$name]['type'] = $type;
+            $this->methods[$name]['arguments'] = $arguments;
         }
     }
 
+    /**
+     * @param string $class
+     * @return string
+     */
     protected function createPhpDocs($class){
 
-        if(strpos($class, '\\') !== false){
+        $reflection = new \ReflectionClass($class);
-            $parts = explode('\\', $class);
+        $namespace = $reflection->getNamespaceName();
-            $class = array_pop($parts);
+        $classname = $reflection->getShortName();
-            $namespace = implode($parts, '\\');
+        $originalDoc = $reflection->getDocComment();
+
+        if($this->reset){
+            $phpdoc = new DocBlock('', new Context($namespace));
         }else{
-            $namespace = '';
+            $phpdoc = new DocBlock($reflection, new Context($namespace));
         }
-        $output = "namespace $namespace{\n";
+
-        $output .= "\t/**\n\t *\n\t * Generated properties for $class\n\t *\n";
+        if(!$phpdoc->getText()){
+            $phpdoc->setText("An Eloquent Model: '$class'");
+        }
+
+        $properties = array();
+        $methods = array();
+        foreach($phpdoc->getTags() as $tag){
+            $name = $tag->getName();
+            if($name == "property" || $name == "property-read" || $name == "property-write"){
+                $properties[] =$tag->getVariableName();
+            }elseif($name == "method"){
+                $methods[] = $tag->getMethodName();
+            }
+        }
+
         foreach($this->properties as $name => $property){
+            $name = "\$$name";
+            if(in_array($name, $properties)){
+                continue;
+            }
             if($property['read'] && $property['write']){
                 $attr = 'property';
             }elseif($property['write']){
@@ -289,17 +366,77 @@ class ModelsCommand extends Command {
             }else{
                 $attr = 'property-read';
             }
-            $type = $property['type'];
+            $tag = Tag::createInstance("@{$attr} {$property['type']} {$name}", $phpdoc);
-            $output .= "\t * @$attr $type \$$name \n";
+            $phpdoc->appendTag($tag);
         }
 
         foreach($this->methods as $name => $method){
-            $type = $method['type'];
+            if(in_array($name, $methods)){
-            $output .= "\t * @method $type $name() \n";
+                continue;
+            }
+            $arguments = implode(', ',$method['arguments']);
+            $tag = Tag::createInstance("@method static {$method['type']} {$name}({$arguments}) ", $phpdoc);
+            $phpdoc->appendTag($tag);
         }
 
-        $output .= "\t *\n\t */\n\tclass $class {}\n}\n\n";
+        $serializer = new DocBlockSerializer();
+        $serializer->getDocComment($phpdoc);
+        $docComment = $serializer->getDocComment($phpdoc);
+
+
+        if($this->write){
+            $filename = $reflection->getFileName();
+            $contents = \File::get($filename);
+            if($originalDoc){
+                $contents = str_replace($originalDoc, $docComment, $contents);
+            }else{
+                $needle = "class {$classname}";
+                $replace = "{$docComment}\nclass {$classname}";
+                $pos = strpos($contents,$needle);
+                if ($pos !== false) {
+                    $contents = substr_replace($contents,$replace,$pos,strlen($needle));
+                }
+            }
+            if(\File::put($filename, $contents)){
+                $this->info('Written new phpDocBlock to '.$filename);
+            }
+        }
+
+        $output = "namespace {$namespace}{\n{$docComment}\n\tclass {$classname} {}\n}\n\n";
         return $output;
     }
 
+    /**
+     * Get the parameters and format them correctly
+     *
+     * @param $method
+     * @return array
+     */
+    public function getParameters($method){
+        //Loop through the default values for paremeters, and make the correct output string
+        $params = array();
+        $paramsWithDefault = array();
+        foreach ($method->getParameters() as $param) {
+            $paramStr = '$'.$param->getName();
+            $params[] = $paramStr;
+            if ($param->isOptional()) {
+                $default = $param->getDefaultValue();
+                if(is_bool($default)){
+                    $default = $default? 'true':'false';
+                }elseif(is_array($default)){
+                    $default = 'array()';
+                }elseif(is_null($default)){
+                    $default = 'null';
+                }elseif(is_int($default)){
+                    //$default = $default;
+                }else{
+                    $default = "'".trim($default)."'";
+                }
+                $paramStr .= " = $default";
+            }
+            $paramsWithDefault[] = $paramStr;
+        }
+        return $paramsWithDefault;
+    }
+
 }

src/config/config.php

@@ -13,18 +13,6 @@ return array(
 
     'filename' => '_ide_helper.php',
 
-    /*
-    |--------------------------------------------------------------------------
-    | Sublime version
-    |--------------------------------------------------------------------------
-    |
-    | Use a different code format, better for SublimeText (instead of Netbeans/phpStorm)
-    | Can also be used with the --sublime (-S) option.
-    |
-    */
-
-    'sublime' => false,
-
     /*
     |--------------------------------------------------------------------------
     | Helper files to include
@@ -52,38 +40,21 @@ return array(
     */
 
     'extra' => array(
-        'Auth'      => array('Illuminate\Auth\Guard'),
+        'Eloquent'  => array('Illuminate\Database\Eloquent\Builder', 'Illuminate\Database\Query\Builder'),
-        'Cache'     => array('Illuminate\Cache\StoreInterface', 'Illuminate\Cache\Repository'),
+        'Session' => array('Illuminate\Session\Store'),
-        'DB'        => array('Illuminate\Database\Connection'),
-        'Eloquent'  => array('Illuminate\Database\Query\Builder'),
-        'Queue'     => array('Illuminate\Queue\QueueInterface'),
     ),
 
-
+    'magic' => array(
-    /*
+        'Log' => array(
-    |--------------------------------------------------------------------------
+            'debug'     => 'Monolog\Logger::addDebug',
-    | Non-static methods
+            'info'      => 'Monolog\Logger::addInfo',
-    |--------------------------------------------------------------------------
+            'notice'    => 'Monolog\Logger::addNotice',
-    |
+            'warning'   => 'Monolog\Logger::addWarning',
-    | These functions aren't actually facade calls, so don't make them static
+            'error'     => 'Monolog\Logger::addError',
-    |
+            'critical'  => 'Monolog\Logger::addCritical',
-    */
+            'alert'     => 'Monolog\Logger::addAlert',
-
+            'emergency' => 'Monolog\Logger::addEmergency',
-    'nonstatic' => array(
+        )
-        'Eloquent'  => array('freshTimestamp', 'newCollection', 'toArray', 'toJson', 'toSql'),
+    )
-    ),
-
-    /*
-    |--------------------------------------------------------------------------
-    | Only extend
-    |--------------------------------------------------------------------------
-    |
-    | These implementations aren't called static, so only extend them.
-    |
-    */
-
-    'only_extend' => array(
-        'Seeder',
-    ),
 
 );