Support for custom builder classes (#782)

See my comment https://github.com/barryvdh/laravel-ide-helper/pull/765#issuecomment-471014271:

The change in #765 made anonymous functions get reflected with `ReflectionMethod` instead of `ReflectionFunction`, which makes it lose the doc comment. This means that the generated helpers are missing their return types. This is because Closure is also an object and callable.

To fix it, Closure should be excluded from that new condition.

.travis.yml

@@ -20,7 +20,7 @@ matrix:
       env: 'COMPOSER_FLAGS="--prefer-stable --prefer-lowest"'
 
 before_script:
-  - travis_retry composer update ${COMPOSER_FLAGS} --no-interaction --prefer-dist
+  - travis_wait 20 travis_retry composer update ${COMPOSER_FLAGS} --no-interaction --prefer-dist
 
 script:
   - vendor/bin/phpcs --standard=psr2 src/

composer.json

@@ -11,15 +11,15 @@
     ],
     "require": {
         "php": ">=7",
-        "illuminate/support": "^5.5,<5.8",
-        "illuminate/console": "^5.5,<5.8",
-        "illuminate/filesystem": "^5.5,<5.8",
-        "barryvdh/reflection-docblock": "^2.0.4",
+        "illuminate/support": "^5.5,<5.9",
+        "illuminate/console": "^5.5,<5.9",
+        "illuminate/filesystem": "^5.5,<5.9",
+        "barryvdh/reflection-docblock": "^2.0.6",
         "composer/composer": "^1.6"
     },
     "require-dev": {
-        "illuminate/config": "^5.1,<5.8",
-        "illuminate/view": "^5.1,<5.8",
+        "illuminate/config": "^5.1,<5.9",
+        "illuminate/view": "^5.1,<5.9",
         "phpro/grumphp": "^0.14",
         "phpunit/phpunit" : "4.*",
         "scrutinizer/ocular": "~1.1",
@@ -46,7 +46,7 @@
     },
     "extra": {
         "branch-alias": {
-            "dev-master": "2.5-dev"
+            "dev-master": "2.6-dev"
         },
         "laravel": {
             "providers": [

config/ide-helper.php

@@ -38,6 +38,21 @@ return array(
 
     'write_model_magic_where' => true,
 
+    /*
+    |--------------------------------------------------------------------------
+    | Write Eloquent Model Mixins
+    |--------------------------------------------------------------------------
+    |
+    | This will add the necessary DocBlock mixins to the model class
+    | contained in the Laravel Framework. This helps the IDE with
+    | auto-completion.
+    |
+    | Please be aware that this setting changes a file within the /vendor directory.
+    |
+    */
+
+    'write_eloquent_model_mixins' => false,
+
     /*
     |--------------------------------------------------------------------------
     | Helper files to include
@@ -178,4 +193,16 @@ return array(
         'integer' => 'int',
         'boolean' => 'bool',
    ),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Include DocBlocks from classes
+    |--------------------------------------------------------------------------
+    |
+    | Include DocBlocks from classes to allow additional code inspection for
+    | magic methods and properties.
+    |
+    */
+    'include_class_docblocks' => false,
+
 );

readme.md

@@ -97,11 +97,11 @@ The `Illuminate/Support/helpers.php` is already set up, but you can add/remove y
 
 ### Automatic phpDocs for models
 
-> You need to require `doctrine/dbal: ~2.3` in your own composer.json to get database columns.
+> You need to add `doctrine/dbal: ~2.3` to require-dev in your own composer.json to get database columns.
 
 
 ```bash
-composer require doctrine/dbal
+composer require --dev doctrine/dbal
 ```
 
 If you don't want to write your properties yourself, you can use the command `php artisan ide-helper:models` to generate

resources/views/helper.php

@@ -1,4 +1,12 @@
 <?= '<?php' ?>
+<?php
+/**
+ * @var \Barryvdh\LaravelIdeHelper\Alias[][] $namespaces_by_alias_ns
+ * @var \Barryvdh\LaravelIdeHelper\Alias[][] $namespaces_by_extends_ns
+ * @var bool $include_fluent
+ * @var string $helpers
+ */
+?>
 
 // @formatter:off
 
@@ -28,7 +36,10 @@ namespace <?= $namespace == '__root' ? '' : trim($namespace, '\\') ?> {
             //Method inherited from <?= $method->getDeclaringClass() ?>
             <?php endif; ?>
 
-            <?= $method->shouldReturn() ? 'return ': '' ?><?= $method->getRoot() ?>::<?= $method->getName() ?>(<?= $method->getParams() ?>);
+            <?php if($method->isInstanceCall()):?>
+            /** @var <?=$method->getRoot()?> $instance */
+            <?php endif?>
+            <?= $method->shouldReturn() ? 'return ': '' ?><?= $method->getRootMethodCall() ?>;
         }
         <?php endforeach; ?> 
     }
@@ -49,8 +60,11 @@ namespace <?= $namespace == '__root' ? '' : trim($namespace, '\\') ?> {
     
                 //Method inherited from <?= $method->getDeclaringClass() ?>
                 <?php endif; ?>
-    
-                <?= $method->shouldReturn() ? 'return ': '' ?><?= $method->getRoot() ?>::<?= $method->getName() ?>(<?= $method->getParams() ?>);
+
+                <?php if($method->isInstanceCall()):?>
+                /** @var <?=$method->getRoot()?> $instance */
+                <?php endif?>
+                <?= $method->shouldReturn() ? 'return ': '' ?><?= $method->getRootMethodCall() ?>;
             }
         <?php endforeach; ?>
 <?php endif; ?>}

src/Alias.php

@@ -10,10 +10,13 @@
 
 namespace Barryvdh\LaravelIdeHelper;
 
+use Closure;
+use ReflectionClass;
 use Barryvdh\Reflection\DocBlock;
 use Barryvdh\Reflection\DocBlock\Context;
+use Barryvdh\Reflection\DocBlock\Tag\MethodTag;
+use Illuminate\Config\Repository as ConfigRepository;
 use Barryvdh\Reflection\DocBlock\Serializer as DocBlockSerializer;
-use ReflectionClass;
 
 class Alias
 {
@@ -34,17 +37,22 @@ class Alias
     protected $interfaces = array();
     protected $phpdoc = null;
 
+    /** @var ConfigRepository  */
+    protected $config;
+
     /**
-     * @param string $alias
-     * @param string $facade
-     * @param array $magicMethods
-     * @param array $interfaces
+     * @param ConfigRepository $config
+     * @param string           $alias
+     * @param string           $facade
+     * @param array            $magicMethods
+     * @param array            $interfaces
      */
-    public function __construct($alias, $facade, $magicMethods = array(), $interfaces = array())
+    public function __construct($config, $alias, $facade, $magicMethods = array(), $interfaces = array())
     {
         $this->alias = $alias;
         $this->magicMethods = $magicMethods;
         $this->interfaces = $interfaces;
+        $this->config = $config;
 
         // Make the class absolute
         $facade = '\\' . ltrim($facade, '\\');
@@ -171,10 +179,14 @@ class Alias
     /**
      * Get the methods found by this Alias
      *
-     * @return array
+     * @return array|Method[]
      */
     public function getMethods()
     {
+        if (count($this->methods) > 0) {
+            return $this->methods;
+        }
+
         $this->addMagicMethods();
         $this->detectMethods();
         return $this->methods;
@@ -310,7 +322,7 @@ class Alias
             $method = new \ReflectionMethod($className, $name);
             $class = new \ReflectionClass($className);
 
-            if (!in_array($method->name, $this->usedMethods)) {
+            if (!in_array($magic, $this->usedMethods)) {
                 if ($class !== $this->root) {
                     $this->methods[] = new Method($method, $this->alias, $class, $magic, $this->interfaces);
                 }
@@ -356,14 +368,17 @@ class Alias
                 $properties = $reflection->getStaticProperties();
                 $macros = isset($properties['macros']) ? $properties['macros'] : [];
                 foreach ($macros as $macro_name => $macro_func) {
-                    // Add macros
-                    $this->methods[] = new Macro(
-                        $this->getMacroFunction($macro_func),
-                        $this->alias,
-                        $reflection,
-                        $macro_name,
-                        $this->interfaces
-                    );
+                    if (!in_array($macro_name, $this->usedMethods)) {
+                        // Add macros
+                        $this->methods[] = new Macro(
+                            $this->getMacroFunction($macro_func),
+                            $this->alias,
+                            $reflection,
+                            $macro_name,
+                            $this->interfaces
+                        );
+                        $this->usedMethods[] = $macro_name;
+                    }
                 }
             }
         }
@@ -381,6 +396,10 @@ class Alias
             return new \ReflectionMethod($macro_func[0], $macro_func[1]);
         }
 
+        if (is_object($macro_func) && is_callable($macro_func) && !$macro_func instanceof Closure) {
+            return new \ReflectionMethod($macro_func, '__invoke');
+        }
+
         return new \ReflectionFunction($macro_func);
     }
 
@@ -395,12 +414,42 @@ class Alias
         $serializer = new DocBlockSerializer(1, $prefix);
 
         if ($this->phpdoc) {
+            if ($this->config->get('ide-helper.include_class_docblocks')) {
+                // if a class doesn't expose any DocBlock tags
+                // we can perform reflection on the class and
+                // add in the original class DocBlock
+                if (count($this->phpdoc->getTags()) === 0) {
+                    $class = new ReflectionClass($this->root);
+                    $this->phpdoc = new DocBlock($class->getDocComment());
+                }
+            }
+
+            $this->removeDuplicateMethodsFromPhpDoc();
             return $serializer->getDocComment($this->phpdoc);
         }
-        
+
         return '';
     }
 
+    /**
+     * Removes method tags from the doc comment that already appear as functions inside the class.
+     * This prevents duplicate function errors in the IDE.
+     *
+     * @return void
+     */
+    protected function removeDuplicateMethodsFromPhpDoc()
+    {
+        $methodNames = array_map(function (Method $method) {
+            return $method->getName();
+        }, $this->getMethods());
+
+        foreach ($this->phpdoc->getTags() as $tag) {
+            if ($tag instanceof MethodTag && in_array($tag->getMethodName(), $methodNames)) {
+                $this->phpdoc->deleteTag($tag);
+            }
+        }
+    }
+
     /**
      * Output an error.
      *

src/Console/GeneratorCommand.php

@@ -115,6 +115,10 @@ class GeneratorCommand extends Command
 
             if ($written !== false) {
                 $this->info("A new helper file was written to $filename");
+
+                if ($this->option('write_mixins')) {
+                    Eloquent::writeEloquentModelHelper($this, $this->files);
+                }
             } else {
                 $this->error("The helper file could not be created at $filename");
             }
@@ -158,9 +162,11 @@ class GeneratorCommand extends Command
     protected function getOptions()
     {
         $format = $this->config->get('ide-helper.format');
+        $writeMixins = $this->config->get('ide-helper.write_eloquent_model_mixins');
 
         return array(
             array('format', "F", InputOption::VALUE_OPTIONAL, 'The format for the IDE Helper', $format),
+            array('write_mixins', "W", InputOption::VALUE_OPTIONAL, 'Write mixins to Laravel Model?', $writeMixins),
             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, 'DEPRECATED: Use different style for SublimeText CodeIntel'),

src/Console/MetaCommand.php

@@ -135,7 +135,7 @@ class MetaCommand extends Command
     protected function registerClassAutoloadExceptions()
     {
         spl_autoload_register(function ($class) {
-            throw new \Exception("Class '$class' not found.");
+            throw new \ReflectionException("Class '$class' not found.");
         });
     }
 

src/Console/ModelsCommand.php

@@ -444,11 +444,19 @@ class ModelsCommand extends Command
                         array_shift($args);
                         $this->setMethod($name, '\Illuminate\Database\Eloquent\Builder|\\' . $reflection->class, $args);
                     }
+                } elseif (in_array($method, ['query', 'newQuery', 'newModelQuery'])) {
+                    $reflection = new \ReflectionClass($model);
+
+                    $builder = get_class($model->newModelQuery());
+
+                    $this->setMethod($method, "\\{$builder}|\\" . $reflection->getName());
                 } elseif (!method_exists('Illuminate\Database\Eloquent\Model', $method)
                     && !Str::startsWith($method, 'get')
                 ) {
                     //Use reflection to inspect the code, based on Illuminate/Support/SerializableClosure.php
                     $reflection = new \ReflectionMethod($model, $method);
+                    // php 7.x type or fallback to docblock
+                    $type = (string) $reflection->getReturnType() ?: (string)$this->getReturnTypeFromDocBlock($reflection);
 
                     $file = new \SplFileObject($reflection->getFileName());
                     $file->seek($reflection->getStartLine() - 1);
@@ -463,23 +471,23 @@ class ModelsCommand extends Command
                     $code = substr($code, $begin, strrpos($code, '}') - $begin + 1);
 
                     foreach (array(
-                               'hasMany',
-                               'hasManyThrough',
-                               'belongsToMany',
-                               'hasOne',
-                               'belongsTo',
-                               'morphOne',
-                               'morphTo',
-                               'morphMany',
-                               'morphToMany',
-                               'morphedByMany'
-                             ) as $relation) {
+                               'hasMany' => '\Illuminate\Database\Eloquent\Relations\HasMany',
+                               'hasManyThrough' => '\Illuminate\Database\Eloquent\Relations\HasManyThrough',
+                               'belongsToMany' => '\Illuminate\Database\Eloquent\Relations\BelongsToMany',
+                               'hasOne' => '\Illuminate\Database\Eloquent\Relations\HasOne',
+                               'belongsTo' => '\Illuminate\Database\Eloquent\Relations\BelongsTo',
+                               'morphOne' => '\Illuminate\Database\Eloquent\Relations\MorphOne',
+                               'morphTo' => '\Illuminate\Database\Eloquent\Relations\MorphTo',
+                               'morphMany' => '\Illuminate\Database\Eloquent\Relations\MorphMany',
+                               'morphToMany' => '\Illuminate\Database\Eloquent\Relations\MorphToMany',
+                               'morphedByMany' => '\Illuminate\Database\Eloquent\Relations\MorphToMany'
+                             ) as $relation => $impl) {
                         $search = '$this->' . $relation . '(';
-                        if ($pos = stripos($code, $search)) {
+                        if (stripos($code, $search) || stripos($impl, (string)$type) !== false) {
                             //Resolve the relation's model to a Relation object.
                             $methodReflection = new \ReflectionMethod($model, $method);
                             if ($methodReflection->getNumberOfParameters()) {
-                                return;
+                                continue;
                             }
 
                             $relationObj = $model->$method();

src/Eloquent.php

@@ -32,27 +32,57 @@ class Eloquent
         $reflection  = new \ReflectionClass($class);
         $namespace   = $reflection->getNamespaceName();
         $originalDoc = $reflection->getDocComment();
+
         if (!$originalDoc) {
             $command->info('Unexpected no document on ' . $class);
         }
         $phpdoc = new DocBlock($reflection, new Context($namespace));
 
         $mixins = $phpdoc->getTagsByName('mixin');
-        foreach ($mixins as $m) {
-            if ($m->getContent() === '\Eloquent') {
-                $command->info('Tag Exists: @mixin \Eloquent in ' . $class);
+        $expectedMixins = [
+            '\Eloquent'                             => false,
+            '\Illuminate\Database\Eloquent\Builder' => false,
+            '\Illuminate\Database\Query\Builder'    => false,
+        ];
 
-                return;
+        foreach ($mixins as $m) {
+            $mixin = $m->getContent();
+
+            if (isset($expectedMixins[$mixin])) {
+                $command->info('Tag Exists: @mixin ' . $mixin . ' in ' . $class);
+
+                $expectedMixins[$mixin] = true;
             }
         }
 
-        // add the Eloquent mixin
-        $phpdoc->appendTag(Tag::createInstance("@mixin \\Eloquent", $phpdoc));
+        $changed = false;
+        foreach ($expectedMixins as $expectedMixin => $present) {
+            if ($present === false) {
+                $phpdoc->appendTag(Tag::createInstance('@mixin ' . $expectedMixin, $phpdoc));
+
+                $changed = true;
+            }
+        }
+
+        // If nothing's changed, stop here.
+        if (!$changed) {
+            return;
+        }
 
         $serializer = new DocBlockSerializer();
         $serializer->getDocComment($phpdoc);
         $docComment = $serializer->getDocComment($phpdoc);
 
+        /*
+            The new DocBlock is appended to the beginning of the class declaration.
+            Since there is no DocBlock, the declaration is used as a guide.
+        */
+        if (!$originalDoc) {
+            $originalDoc = 'abstract class Model implements';
+
+            $docComment .= "\nabstract class Model implements";
+        }
+
         $filename = $reflection->getFileName();
         if ($filename) {
             $contents = $files->get($filename);
@@ -61,7 +91,7 @@ class Eloquent
                 $contents = str_replace($originalDoc, $docComment, $contents, $count);
                 if ($count > 0) {
                     if ($files->put($filename, $contents)) {
-                        $command->info('Wrote @mixin \Eloquent to ' . $filename);
+                        $command->info('Wrote expected docblock to ' . $filename);
                     } else {
                         $command->error('File write failed to ' . $filename);
                     }

src/Generator.php

@@ -198,12 +198,12 @@ class Generator
         // Get all aliases
         foreach ($this->getAliases() as $name => $facade) {
             // Skip the Redis facade, if not available (otherwise Fatal PHP Error)
-            if ($facade == 'Illuminate\Support\Facades\Redis' && !class_exists('Predis\Client')) {
+            if ($facade == 'Illuminate\Support\Facades\Redis' && $name == 'Redis' && !class_exists('Predis\Client')) {
                 continue;
             }
 
             $magicMethods = array_key_exists($name, $this->magic) ? $this->magic[$name] : array();
-            $alias = new Alias($name, $facade, $magicMethods, $this->interfaces);
+            $alias = new Alias($this->config, $name, $facade, $magicMethods, $this->interfaces);
             if ($alias->isValid()) {
                 //Add extra methods, from other classes (magic static calls)
                 if (array_key_exists($name, $this->extra)) {
@@ -272,9 +272,13 @@ class Generator
         $facades = array_merge($facades, $this->config->get('app.aliases', []));
 
         // Only return the ones that actually exist
-        return array_filter($facades, function ($alias) {
-            return class_exists($alias);
-        });
+        return array_filter(
+            $facades,
+            function ($alias) {
+                return class_exists($alias);
+            },
+            ARRAY_FILTER_USE_KEY
+        );
     }
 
     /**

src/IdeHelperServiceProvider.php

@@ -37,8 +37,10 @@ class IdeHelperServiceProvider extends ServiceProvider
      */
     public function boot()
     {
-        $viewPath = __DIR__.'/../resources/views';
-        $this->loadViewsFrom($viewPath, 'ide-helper');
+        if ($this->app->has('view')) {
+            $viewPath = __DIR__ . '/../resources/views';
+            $this->loadViewsFrom($viewPath, 'ide-helper');
+        }
 
         $configPath = __DIR__ . '/../config/ide-helper.php';
         if (function_exists('config_path')) {

src/Macro.php

@@ -17,36 +17,30 @@ class Macro extends Method
      * @param array               $interfaces
      */
     public function __construct(
-        \ReflectionFunctionAbstract $method,
+        $method,
         $alias,
         $class,
         $methodName = null,
         $interfaces = array()
     ) {
-        $this->method = $method;
-        $this->interfaces = $interfaces;
-        $this->name = $methodName ?: $method->name;
-        $this->namespace = $class->getNamespaceName();
+        parent::__construct($method, $alias, $class, $methodName, $interfaces);
+    }
 
-        //Create a DocBlock and serializer instance
+    /**
+     * @param \ReflectionFunctionAbstract $method
+     */
+    protected function initPhpDoc($method)
+    {
         $this->phpdoc = new DocBlock($method);
+    }
 
-        //Normalize the description and inherit the docs from parents/interfaces
-        try {
-            $this->normalizeParams($this->phpdoc);
-            $this->normalizeReturn($this->phpdoc);
-            $this->normalizeDescription($this->phpdoc);
-        } catch (\Exception $e) {
-        }
-
-        //Get the parameters, including formatted default values
-        $this->getParameters($method);
-
-        //Make the method static
-        $this->phpdoc->appendTag(Tag::createInstance('@static', $this->phpdoc));
-
-        //Reference the 'real' function in the declaringclass
+    /**
+     * @param \ReflectionFunctionAbstract $method
+     * @param \ReflectionClass $class
+     */
+    protected function initClassDefinedProperties($method, \ReflectionClass $class)
+    {
+        $this->namespace = $class->getNamespaceName();
         $this->declaringClassName = '\\' . ltrim($class->name, '\\');
-        $this->root = '\\' . ltrim($class->getName(), '\\');
     }
 }

src/Method.php

@@ -26,29 +26,36 @@ class Method
     protected $method;
 
     protected $output = '';
+    protected $declaringClassName;
     protected $name;
     protected $namespace;
     protected $params = array();
     protected $params_with_default = array();
     protected $interfaces = array();
+    protected $real_name;
     protected $return = null;
+    protected $root;
 
     /**
-     * @param \ReflectionMethod $method
+     * @param \ReflectionMethod|\ReflectionFunctionAbstract $method
      * @param string $alias
      * @param \ReflectionClass $class
      * @param string|null $methodName
      * @param array $interfaces
      */
-    public function __construct(\ReflectionMethod $method, $alias, $class, $methodName = null, $interfaces = array())
+    public function __construct($method, $alias, $class, $methodName = null, $interfaces = array())
     {
         $this->method = $method;
         $this->interfaces = $interfaces;
         $this->name = $methodName ?: $method->name;
-        $this->namespace = $method->getDeclaringClass()->getNamespaceName();
+        $this->real_name = $method->isClosure() ? $this->name : $method->name;
+        $this->initClassDefinedProperties($method, $class);
+
+        //Reference the 'real' function in the declaring class
+        $this->root = '\\' . ltrim($class->getName(), '\\');
 
         //Create a DocBlock and serializer instance
-        $this->phpdoc = new DocBlock($method, new Context($this->namespace));
+        $this->initPhpDoc($method);
 
         //Normalize the description and inherit the docs from parents/interfaces
         try {
@@ -63,11 +70,25 @@ class Method
 
         //Make the method static
         $this->phpdoc->appendTag(Tag::createInstance('@static', $this->phpdoc));
+    }
 
-        //Reference the 'real' function in the declaringclass
+    /**
+     * @param \ReflectionMethod $method
+     */
+    protected function initPhpDoc($method)
+    {
+        $this->phpdoc = new DocBlock($method, new Context($this->namespace));
+    }
+
+    /**
+     * @param \ReflectionMethod $method
+     * @param \ReflectionClass $class
+     */
+    protected function initClassDefinedProperties($method, \ReflectionClass $class)
+    {
         $declaringClass = $method->getDeclaringClass();
+        $this->namespace = $declaringClass->getNamespaceName();
         $this->declaringClassName = '\\' . ltrim($declaringClass->name, '\\');
-        $this->root = '\\' . ltrim($class->getName(), '\\');
     }
 
     /**
@@ -90,6 +111,26 @@ class Method
         return $this->root;
     }
 
+    /**
+     * @return bool
+     */
+    public function isInstanceCall()
+    {
+        return ! ($this->method->isClosure() || $this->method->isStatic());
+    }
+
+    /**
+     * @return string
+     */
+    public function getRootMethodCall()
+    {
+        if ($this->isInstanceCall()) {
+            return "\$instance->{$this->getRealName()}({$this->getParams()})";
+        } else {
+            return "{$this->getRoot()}::{$this->getRealName()}({$this->getParams()})";
+        }
+    }
+
     /**
      * Get the docblock for this method
      *
@@ -112,6 +153,16 @@ class Method
         return $this->name;
     }
 
+    /**
+     * Get the real method name
+     *
+     * @return string
+     */
+    public function getRealName()
+    {
+        return $this->real_name;
+    }
+
     /**
      * Get the parameters for this method
      *
@@ -213,6 +264,10 @@ class Method
             // Set the changed content
             $tag->setContent($returnValue . ' ' . $tag->getDescription());
             $this->return = $returnValue;
+
+            if ($tag->getType() === '$this') {
+                $tag->setType($this->root);
+            }
         } else {
             $this->return = null;
         }