Require doctrine for dev

Fixes #83

composer.json

@@ -14,13 +14,24 @@
         "illuminate/support": "4.x",
         "illuminate/console": "4.x",
         "illuminate/filesystem": "4.x",
-        "barryvdh/reflection-docblock": ">=2.0.1",
+        "phpdocumentor/reflection-docblock": "2.0.x",
         "symfony/class-loader": "~2.3"
     },
+    "require-dev": {
+        "doctrine/dbal": "~2.3"
+    },
+    "suggest": {
+        "doctrine/dbal": "Load information from the database about models for phpdocs (~2.3)"
+    },
     "autoload": {
         "psr-0": {
             "Barryvdh\\LaravelIdeHelper": "src/"
         }
     },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "1.x-dev"
+        }
+    },
     "minimum-stability": "dev"
 }

provides.json

@@ -0,0 +1,5 @@
+{
+  "providers": [
+    "Barryvdh\LaravelIdeHelper\IdeHelperServiceProvider"
+  ]
+}

readme.md

@@ -3,6 +3,8 @@
 
 ### Complete phpDocs, directly from the source
 
+_Checkout [this Laracasts video](https://laracasts.com/series/how-to-be-awesome-in-phpstorm/episodes/15) for a quick introduction/explanation!_
+
 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)
 
@@ -30,6 +32,7 @@ You can configure your composer.json to do this after each commit:
 
     "scripts":{
         "post-update-cmd":[
+            "php artisan clear-compiled",
             "php artisan ide-helper:generate",
             "php artisan optimize",
         ]
@@ -50,11 +53,11 @@ The Illuminate/Support/helpers.php is already set-up, but you can add/remove you
 
 ### Automatic phpDocs for Models
 
-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. Still in beta, so please provide feedback if you want.
-Docs are written to a phpfile (_ide_helper_models.php) in the root of the project, so you can move the docs to the real model.
+> **Note:** Since v1.10 you need to require `doctrine/dbal: ~2.3` in your own composer.json. 
 
-You can now also write the comments directly to your Model file, using the `--write (-W)` option. Please make sure to backup your models, before writing the info.
+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. You can write the comments directly to your Model file, using the `--write (-W)` option. By default, you are asked to overwrite or write to a separate file (\_ide\_helper\_models.php) (You can force No with `--nowrite (-N)`).
+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.
 
@@ -73,11 +76,21 @@ With the `--reset (-R)` option, the existing phpdocs are ignored, only the newly
      * @property-read \Illuminate\Database\Eloquent\Collection|\Comment[] $comments
      */
 
-For now, only models in app/models are scanned. The optional argument tells what models to use (also outside app/models).
+By default, models in app/models are scanned. The optional argument tells what models to use (also outside app/models).
 
-    php artisan ide-helper:models Post,User
+    php artisan ide-helper:models Post User
 
-Note: With namespaces, uses `\\` instead of `\`: `php artisan ide-helper:models API\\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" --dir="app/src/Model"
+   
+You can publish the config file (`php artisan config:publish barryvdh/laravel-ide-helper`) and set the default directories.
+
+Models can be ignored using the --ignore (-I) option
+
+    php artisan ide-helper:models --ignore="Post,User"
+
+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

@@ -13,10 +13,10 @@ use Illuminate\Console\Command;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Input\InputArgument;
 use Illuminate\Foundation\AliasLoader;
-use Barryvdh\Reflection\DocBlock;
-use Barryvdh\Reflection\DocBlock\Context;
-use Barryvdh\Reflection\DocBlock\Tag;
-use Barryvdh\Reflection\DocBlock\Serializer as DocBlockSerializer;
+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
  *
@@ -41,6 +41,7 @@ class GeneratorCommand extends Command {
     protected $extra;
     protected $onlyExtend;
     protected $helpers;
+    protected $magic;
 
 
     /**
@@ -60,6 +61,7 @@ class GeneratorCommand extends Command {
             }
     
             $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');
@@ -123,70 +125,98 @@ class GeneratorCommand extends Command {
 
         $aliasLoader = AliasLoader::getInstance();
 
-        $output = "<?php
+        $outputString = "<?php
 /**
  * An helper file for Laravel 4, to provide autocomplete information to your IDE
  * Generated with https://github.com/barryvdh/laravel-ide-helper
  *
  * @author Barry vd. Heuvel <[email protected]>
- */
-exit('Only to be used as an helper for your IDE');\n\n";
+ */\n\n";
+        $output['__root'] = "\texit('Only to be used as an helper for your IDE');\n\n";
 
         //Get all aliases
         $aliases = $aliasLoader->getAliases();
 
         foreach($aliases as $alias => $facade){
-
+            //Check if the facade is not a Trait
+            if(function_exists('trait_exists') && trait_exists($facade)){
+                continue;
+            }
+            $facade = '\\'.ltrim($facade, '\\');
             $root = $this->getRoot($facade);
             if(!$root){
                 continue;
             }
 
             try{
+                if (strpos($alias, '\\')){
+                    $nsParts = explode('\\', $alias);
+                    $alias = array_pop($nsParts);
+                    $ns = implode('\\', $nsParts);
+                } else {
+                    $ns = '__root';
+                }
+                if (!isset($output[$ns])) $output[$ns] = '';
 
                 //Some classes extend the facade
-                if(class_exists($facade)){
-                    $output .= "class $alias extends $facade{\n";
+                if(interface_exists($facade)){
+                    $output[$ns] .= "\tinterface $alias extends $facade{\n";
+                }elseif(class_exists($facade)){
+                    $output[$ns] .= "\tclass $alias extends $facade{\n";
                 }else{
-                    $output .= "class $alias{\n";
+                    $output[$ns] .= "\tclass $alias{\n";
                 }
 
                 $usedMethods = array();
 
                 //Only add the methods to the output when the root is not the same as the facade.
                 $addOutput = ($root !== $facade);
-                $output .= $this->getMethods($root, $alias, $usedMethods, $addOutput);
+                $output[$ns] .= $this->getMethods($root, $alias, $usedMethods, $addOutput);
 
 
                 $driver =  $this->getDriver($alias);
                 if($driver){
-                    $output .= $this->getMethods($driver, $alias, $usedMethods);
+                    $output[$ns] .= $this->getMethods($driver, $alias, $usedMethods);
                 }
 
                 //Add extra methods, from other classes (magic static calls)
                 if(array_key_exists($alias, $this->extra)){
-                    $output .= $this->getMethods($this->extra[$alias], $alias, $usedMethods);
+                    $output[$ns] .= $this->getMethods($this->extra[$alias], $alias, $usedMethods);
+                }
+
+                //Add extra methods, from other classes (magic static calls)
+                if(array_key_exists($alias, $this->magic)){
+                    $output[$ns] .= $this->addMagicMethods($this->magic[$alias], $alias, $usedMethods);
                 }
 
 
-                $output .= "}\n\n";
+                $output[$ns] .= "\t}\n";
 
             }catch(\Exception $e){
                 $this->error("Exception: ".$e->getMessage()."\nCould not analyze $root.");
             }
 
         }
-
+        
         //Include the helper file, if requested
-        if(!empty($helpers)){
-            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));
+                    $output['__root'] .= str_replace(array('<?php', '?>'), '',  \File::get($helper));
                 }
             }
         }
 
-        return $output;
+        foreach ($output as $ns => $body){
+            if ($ns == '__root'){
+                $ns = '';
+            }
+            $outputString .= "namespace $ns{\n";
+            $outputString .= $body;
+            $outputString .= "}\n\n";
+        }
+
+        return $outputString;
     }
 
     /**
@@ -223,20 +253,33 @@ exit('Only to be used as an helper for your IDE');\n\n";
 
     }
 
+    /**
+     * Get the driver/connection/store from the managers
+     *
+     * @param $alias
+     * @return array|bool|string
+     */
     public function getDriver($alias){
-        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{
+        try{
+            if($alias == "Auth"){
+                $driver = \Auth::driver();
+            }elseif($alias == "DB"){
+                $driver = \DB::connection();
+            }elseif($alias == "Cache"){
+                $driver = get_class(\Cache::driver());
+                $store = get_class(\Cache::getStore());
+                return array($driver, $store);
+            }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;
         }
-
-        return get_class($driver);
     }
 
     /**
@@ -277,29 +320,69 @@ exit('Only to be used as an helper for your IDE');\n\n";
     }
 
     /**
-     * @param \ReflectionMethod $method
-     * @param string $alias
+     * Get the methods for one or multiple magic methods.
+     *
+     * @param $methods
+     * @param $alias
+     * @param $usedMethods
+     * @param bool $addOutput
      * @return string
      */
-    protected function parseMethod($method, $alias, $class){
+    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");
+        $serializer = new DocBlockSerializer(1, "\t\t");
 
         //Normalize the description and inherit the docs from parents/interfaces
-        $this->normalizeDescription($phpdoc, $method);
+        try{
+            $this->normalizeDescription($phpdoc, $method);
+        }catch(\Exception $e){
+            $this->info("Cannot normalize method $alias::$methodName..");
+        }
 
         //Correct the return values
-        $returnValue = $this->normalizeReturn($phpdoc, $method, $alias);
+        $returnValue = $this->getReturn($phpdoc);
 
         //Get the parameters, including formatted default values
         list($params, $paramsWithDefault) = $this->getParameters($method);
@@ -308,27 +391,28 @@ exit('Only to be used as an helper for your IDE');\n\n";
         $phpdoc->appendTag(Tag::createInstance('@static', $phpdoc));
 
         //Write the output, using the DocBlock serializer
-        $output .= $serializer->getDocComment($phpdoc) ."\n\t public static function ".$method->name."(";
+        $output .= $serializer->getDocComment($phpdoc) ."\n\t\t public static function ".$methodName."(";
 
         $output .= implode($paramsWithDefault, ", ");
-        $output .= "){\r\n";
+        $output .= "){\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();
+        $declaringClassName = '\\'.ltrim($declaringClass->name, '\\');
+        $root = '\\'.ltrim($class->getName(), '\\');
 
         if($declaringClass->name != $root){
-            $output .= "\t\t//Method inherited from $declaringClass->name\r\n";
+            $output .= "\t\t\t//Method inherited from $declaringClassName\n";
         }
 
-        $output .=  "\t\t$return $root::";
+        $output .=  "\t\t\t$return $root::";
 
         //Write the default parameters in the function call
-        $output .=  $method->name."(".implode($params, ", ").");\r\n";
-        $output .= "\t }\n\n";
+        $output .=  $method->name."(".implode($params, ", ").");\n";
+        $output .= "\t\t }\n\n";
 
         return $output;
     }
@@ -366,23 +450,15 @@ exit('Only to be used as an helper for your IDE');\n\n";
      * Make some changes to the return types, if needed.
      *
      * @param $phpdoc
-     * @param $method
-     * @param $alias
-     * @return null
+     * @return string|null
      */
-    protected function normalizeReturn(&$phpdoc, $method, $alias){
+    protected function getReturn($phpdoc){
         //Get the return type and adjust them for beter autocomplete
         $returnTags = $phpdoc->getTagsByName('return');
         if($returnTags){
             /** @var  $tag */
             $tag = reset($returnTags);
             $returnValue = $tag->getType();
-
-            if($method->name == "__construct"){
-                $tag->setType('self');
-            }elseif($alias == 'Eloquent' and in_array($method->name, array('hasOne', 'hasMany', 'belongsTo', 'belongsToMany', 'morphOne', 'morphTo', 'morphMany'))){
-                $tag->addType('\Eloquent');
-            }
         }else{
             $returnValue = null;
         }

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

@@ -3,20 +3,23 @@
  * Laravel IDE Helper Generator
  *
  * @author    Barry vd. Heuvel <[email protected]>
- * @copyright 2013 Barry vd. Heuvel / Fruitcake Studio (http://www.fruitcakestudio.nl)
+ * @copyright 2014 Barry vd. Heuvel / Fruitcake Studio (http://www.fruitcakestudio.nl)
  * @license   http://www.opensource.org/licenses/mit-license.php MIT
  * @link      https://github.com/barryvdh/laravel-ide-helper
  */
 
 namespace Barryvdh\LaravelIdeHelper;
+
 use Illuminate\Console\Command;
+use Illuminate\Support\Str;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\ClassLoader\ClassMapGenerator;
-use Barryvdh\Reflection\DocBlock;
-use Barryvdh\Reflection\DocBlock\Context;
-use Barryvdh\Reflection\DocBlock\Tag;
-use Barryvdh\Reflection\DocBlock\Serializer as DocBlockSerializer;
+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
  *
@@ -30,6 +33,7 @@ class ModelsCommand extends Command {
      * @var string
      */
     protected $name = 'ide-helper:models';
+    protected $filename = '_ide_helper_models.php';
 
     /**
      * The console command description.
@@ -41,7 +45,7 @@ class ModelsCommand extends Command {
     protected $properties = array();
     protected $methods = array();
     protected $write = false;
-    protected $dir;
+    protected $dirs = array();
     protected $reset;
 
 
@@ -55,11 +59,19 @@ class ModelsCommand extends Command {
     {
         $filename = $this->option('filename');
         $this->write = $this->option('write');
-        $this->dir = $this->option('dir');
+        $this->dirs = array_merge($this->laravel['config']->get('laravel-ide-helper::model_locations'), $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')){
+            if($this->confirm("Do you want to overwrite the existing model files? Choose no to write to $filename instead? (Yes/No): ")){
+                $this->write = true;
+            }
+        }
+
+        $content = $this->generateDocs($model, $ignore);
 
         if(!$this->write){
             $written = \File::put($filename, $content);
@@ -69,7 +81,6 @@ class ModelsCommand extends Command {
                 $this->error("Failed to write model information to $filename");
             }
         }
-
     }
 
 
@@ -81,8 +92,7 @@ class ModelsCommand extends Command {
     protected function getArguments()
     {
         return array(
-            array('model', InputArgument::OPTIONAL, 'Which models to include', '*'),
-
+            array('model', InputArgument::OPTIONAL | InputArgument::IS_ARRAY, 'Which models to include', array()),
         );
     }
 
@@ -94,14 +104,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('dir', 'D', InputOption::VALUE_OPTIONAL, 'The model dir','app/models'),
+            array('filename', 'F', InputOption::VALUE_OPTIONAL, 'The path to the helper file', $this->filename),
+            array('dir', 'D', InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY, 'The model dir', array()),
             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($loadModels, $ignore = ''){
 
 
         $output = "<?php
@@ -114,19 +126,43 @@ class ModelsCommand extends Command {
  */
 \n\n";
 
-        if($model === '*'){
+        $hasDoctrine = interface_exists('Doctrine\DBAL\Driver');
+        
+        if(empty($loadModels)){
             $models = $this->loadModels();
         }else{
-            $models = explode(',', $model);
+            $models = array();
+            foreach($loadModels as $model){
+                $models = array_merge($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)){
-                try{
+                try {
+                    // handle abstract classes, interfaces, ...
+                    $reflectionClass = new \ReflectionClass($name);
+                    if (!$reflectionClass->IsInstantiable()) {
+                        throw new \Exception($name . ' is not instanciable.');
+                    }elseif(!$reflectionClass->isSubclassOf('Illuminate\Database\Eloquent\Model')){
+                        $this->comment("Class '$name' is not a model");
+                        continue;
+                    }
+
                     $model = new $name();
-                    $this->getPropertiesFromTable($model);
+                    if($hasDoctrine){
+                        $this->getPropertiesFromTable($model);
+                    }
                     $this->getPropertiesFromMethods($model);
                     $output .= $this->createPhpDocs($name);
                 }catch(\Exception $e){
@@ -137,6 +173,10 @@ class ModelsCommand extends Command {
             }
 
         }
+        
+        if(!$hasDoctrine){
+            $this->error("Warning: 'doctrine/dbal: ~2.3' is required to load database information. Please require that in your composer.json and run 'composer update'.");
+        }
 
         return $output;
 
@@ -144,11 +184,13 @@ class ModelsCommand extends Command {
 
 
     protected function loadModels(){
-        $dir = base_path().'/'.$this->dir;
         $models = array();
-        if(file_exists($dir)){
-            foreach(ClassMapGenerator::createMap($dir) as $model=> $path){
-                $models[] = $model;
+        foreach($this->dirs as $dir){
+            $dir = base_path() . '/' . $dir;
+            if(file_exists($dir)){
+                foreach(ClassMapGenerator::createMap($dir) as $model=> $path){
+                    $models[] = $model;
+                }
             }
         }
         return $models;
@@ -160,7 +202,7 @@ class ModelsCommand extends Command {
      * @param \Illuminate\Database\Eloquent\Model $model
      */
     protected function getPropertiesFromTable($model){
-        $table = $model->getTable();
+        $table = $model->getConnection()->getTablePrefix() . $model->getTable();
         $schema = $model->getConnection()->getDoctrineSchemaManager($table);
         $schema->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string');
 
@@ -169,37 +211,41 @@ class ModelsCommand extends Command {
         if($columns){
             foreach ($columns as $column) {
                 $name = $column->getName();
-                $type =  $column->getType()->getName();
-
-                switch($type){
-                    case 'string':
-                    case 'text':
-                    case 'date':
-                    case 'time':
-                    case 'guid':
-                        $type = 'string';
-                        break;
-                    case 'integer':
-                    case 'bigint':
-                    case 'smallint':
-                        $type = 'integer';
-                        break;
-                    case 'decimal':
+                if(in_array($name, $model->getDates())){
+                    $type = '\Carbon\Carbon';
+                }else{
+                    $type =  $column->getType()->getName();
+                    switch($type){
+                        case 'string':
+                        case 'text':
+                        case 'date':
+                        case 'time':
+                        case 'guid':
+                        case 'datetimetz':
+                        case 'datetime':
+                            $type = 'string';
+                            break;
+                        case 'integer':
+                        case 'bigint':
+                        case 'smallint':
+                            $type = 'integer';
+                            break;
+                        case 'decimal':
                         case 'float':
-                        $type = 'float';
-                        break;
-                    case 'boolean':
-                        $type = 'boolean';
-                        break;
-                    case 'datetimetz':  //String or DateTime, depending on $dates
-                    case 'datetime':
-                        $type = '\Carbon\Carbon';
-                        break;
-                    default:
-                        $type = 'mixed';
-                        break;
+                            $type = 'float';
+                            break;
+                        case 'boolean':
+                            $type = 'boolean';
+                            break;
+                        default:
+                            $type = 'mixed';
+                            break;
+                    }
                 }
+
+
                 $this->setProperty($name, $type, true, true);
+                $this->setMethod(Str::camel("where_".$name), '\Illuminate\Database\Query\Builder|\\'.get_class($model), array('$value'));
             }
         }
     }
@@ -210,62 +256,64 @@ class ModelsCommand extends Command {
     protected function getPropertiesFromMethods($model){
         $methods = get_class_methods($model);
         if($methods){
-           foreach($methods as $method){
-               if(\Str::startsWith($method, 'get') && \Str::endsWith($method, 'Attribute') && $method !== 'setAttribute'){
-                   //Magic get<name>Attribute
-                   $name =  \Str::snake(substr($method, 3, -9));
-                   if(!empty($name)){
+            foreach($methods as $method){
+                if(Str::startsWith($method, 'get') && Str::endsWith($method, 'Attribute') && $method !== 'getAttribute'){
+                    //Magic get<name>Attribute
+                    $name =  Str::snake(substr($method, 3, -9));
+                    if(!empty($name)){
                         $this->setProperty($name, null, true, null);
-                   }
-               }elseif(\Str::startsWith($method, 'set') && \Str::endsWith($method, 'Attribute') && $method !== 'setAttribute'){
-                   //Magic set<name>Attribute
-                   $name =  \Str::snake(substr($method, 3, -9));
-                   if(!empty($name)){
+                    }
+                }elseif(Str::startsWith($method, 'set') && Str::endsWith($method, 'Attribute') && $method !== 'setAttribute'){
+                    //Magic set<name>Attribute
+                    $name =  Str::snake(substr($method, 3, -9));
+                    if(!empty($name)){
                         $this->setProperty($name, null, null, true);
-                   }
-               }elseif(\Str::startsWith($method, 'scope') && $method !== 'scopeQuery'){
-                   //Magic set<name>Attribute
-                   $name =  \Str::snake(substr($method, 5));
-                   if(!empty($name)){
-                       $this->setMethod($name, 'static');
-                   }
-               }elseif(!method_exists('Eloquent', $method) && !\Str::startsWith($method, 'get')){
+                    }
+                }elseif(Str::startsWith($method, 'scope') && $method !== 'scopeQuery'){
+                    //Magic set<name>Attribute
+                    $name =  Str::camel(substr($method, 5));
+                    if(!empty($name)){
+                        $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')){
 
-                   //Use reflection to inspect the code, based on Illuminate/Support/SerializableClosure.php
-                   $reflection = new \ReflectionMethod($model, $method);
+                    //Use reflection to inspect the code, based on Illuminate/Support/SerializableClosure.php
+                    $reflection = new \ReflectionMethod($model, $method);
 
-                   $file = new \SplFileObject($reflection->getFileName());
-                   $file->seek($reflection->getStartLine() - 1);
+                    $file = new \SplFileObject($reflection->getFileName());
+                    $file->seek($reflection->getStartLine() - 1);
 
-                   $code = '';
-                   while ($file->key() < $reflection->getEndLine())
-                   {
-                       $code .= $file->current(); $file->next();
-                   }
-                   $begin = strpos($code, 'function(');
-                   $code = substr($code, $begin, strrpos($code, '}') - $begin + 1);
+                    $code = '';
+                    while ($file->key() < $reflection->getEndLine())
+                    {
+                        $code .= $file->current(); $file->next();
+                    }
+                    $begin = strpos($code, 'function(');
+                    $code = substr($code, $begin, strrpos($code, '}') - $begin + 1);
 
-                   $begin = stripos($code, 'return $this->');
-                   $parts = explode("'", substr($code, $begin+14),3);  //"return $this->" is 14 chars
-                   if (isset($parts[2]))
-                   {
-                       list($relation, $returnModel, $rest) = $parts;
-                       $returnModel = "\\".ltrim($returnModel, "\\");
-                       $relation = trim($relation, ' (');
-    
-                       if($relation === "belongsTo" or $relation === 'hasOne'){
-                           //Single model is returned
-                           $this->setProperty($method, $returnModel, true, null);
-                       }elseif($relation === "belongsToMany" or $relation === 'hasMany'){
-                           //Collection or array of models (because Collection is Arrayable)
-                           $this->setProperty($method,  '\Illuminate\Database\Eloquent\Collection|'.$returnModel.'[]', true, null);
-                       }
-                   }else{
-                       //Not a relation
-                   }
+                    foreach(array('hasMany', 'belongsToMany', 'hasOne', 'belongsTo', 'morphTo', 'morphMany', 'morphToMany') as $relation){
+                        $search = '$this->'.$relation.'(';
+                        if($pos = stripos($code, $search)){
+                            $code = substr($code, $pos + strlen($search));
+                            $arguments = explode(',', substr($code, 0, stripos($code, ')')));
+                            //Remove quotes, ensure 1 \ in front of the model
+                            $returnModel = "\\".ltrim(trim($arguments[0], " \"'"), "\\");
+                            if($relation === "belongsToMany" or $relation === 'hasMany' or $relation === 'morphMany' or $relation === 'morphToMany'){
+                                //Collection or array of models (because Collection is Arrayable)
+                                $this->setProperty($method,  '\Illuminate\Database\Eloquent\Collection|'.$returnModel.'[]', true, null);
+                            }else{
+                                //Single model is returned
+                                $this->setProperty($method, $returnModel, true, null);
+                            }
+                        }
+                    }
 
-               }
-           }
+                }
+            }
         }
     }
 
@@ -293,13 +341,11 @@ 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;
         }
     }
 
@@ -321,7 +367,7 @@ class ModelsCommand extends Command {
         }
 
         if(!$phpdoc->getText()){
-            $phpdoc->setText("An Eloquent Model: '$class'");
+            $phpdoc->setText($class);
         }
 
         $properties = array();
@@ -355,8 +401,8 @@ class ModelsCommand extends Command {
             if(in_array($name, $methods)){
                 continue;
             }
-            $name = "$name()";
-            $tag = Tag::createInstance("@method {$method['type']} {$name}", $phpdoc);
+            $arguments = implode(', ',$method['arguments']);
+            $tag = Tag::createInstance("@method static {$method['type']} {$name}({$arguments}) ", $phpdoc);
             $phpdoc->appendTag($tag);
         }
 
@@ -387,4 +433,37 @@ class ModelsCommand extends Command {
         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

@@ -29,6 +29,20 @@ return array(
         base_path().'/vendor/laravel/framework/src/Illuminate/Support/helpers.php',
     ),
 
+    /*
+    |--------------------------------------------------------------------------
+    | Model locations to include
+    |--------------------------------------------------------------------------
+    |
+    | Define in which directories the ide-helper:models command should look
+    | for models.
+    |
+    */
+
+    'model_locations' => array(
+        'app/models',
+    ),
+
 
     /*
     |--------------------------------------------------------------------------
@@ -40,7 +54,22 @@ return array(
     */
 
     'extra' => array(
-        'Eloquent'  => array('Illuminate\Database\Eloquent\Builder', 'Illuminate\Database\Query\Builder'),
+        'Artisan' => array('Illuminate\Foundation\Artisan'),
+        'Eloquent' => array('Illuminate\Database\Eloquent\Builder', 'Illuminate\Database\Query\Builder'),
+        'Session' => array('Illuminate\Session\Store'),
     ),
 
+    'magic' => array(
+        'Log' => array(
+            'debug'     => 'Monolog\Logger::addDebug',
+            'info'      => 'Monolog\Logger::addInfo',
+            'notice'    => 'Monolog\Logger::addNotice',
+            'warning'   => 'Monolog\Logger::addWarning',
+            'error'     => 'Monolog\Logger::addError',
+            'critical'  => 'Monolog\Logger::addCritical',
+            'alert'     => 'Monolog\Logger::addAlert',
+            'emergency' => 'Monolog\Logger::addEmergency',
+        )
+    )
+
 );