Add Fluent helpers (using config option) (#404 )

* add fluent option to Generator * add fluent to helper output * add fluent option to config * typo
Merge pull request #397 from ockle/scope-typehints
2026-08-18 01:57:13 +00:00 · 2016-11-15 09:21:23 +01:00 · 2016-10-13 09:23:59 +02:00 · 2016-10-12 21:53:42 +01:00 · 2016-09-08 08:54:27 +02:00 · 2016-09-07 15:05:31 +02:00
25 changed files with 2693 additions and 983 deletions
@@ -0,0 +1,15 @@
 ; This file is for unifying the coding style for different editors and IDEs.
 ; More information at http://editorconfig.org
 root = true
 [*]
 charset = utf-8
 indent_size = 4
 indent_style = space
 end_of_line = lf
 insert_final_newline = true
 trim_trailing_whitespace = true
 [*.md]
 trim_trailing_whitespace = false
@@ -0,0 +1,10 @@
 # Path-based git attributes
 # https://www.kernel.org/pub/software/scm/git/docs/gitattributes.html
 # Ignore all test and documentation with "export-ignore".
 /.gitattributes     export-ignore
 /.gitignore         export-ignore
 /.travis.yml        export-ignore
 /phpunit.xml.dist   export-ignore
 /.scrutinizer.yml   export-ignore
 /tests              export-ignore
@@ -1,3 +1,4 @@
-/vendor
+build
 vendor
 composer.lock
 .idea
@@ -0,0 +1,23 @@
 filter:
    excluded_paths: [tests/*]
 checks:
    php:
        remove_extra_empty_lines: true
        remove_php_closing_tag: true
        remove_trailing_whitespace: true
        fix_use_statements:
            remove_unused: true
            preserve_multiple: false
            preserve_blanklines: true
            order_alphabetically: true
        fix_php_opening_tag: true
        fix_linefeed: true
        fix_line_ending: true
        fix_identation_4spaces: true
        fix_doc_comments: true
 tools:
    external_code_coverage:
        timeout: 600
        runs: 3
@@ -0,0 +1 @@
 preset: psr2
@@ -0,0 +1,31 @@
 language: php
 php:
  - 5.5
  - 5.6
  - 7.0
  - hhvm
 # This triggers builds to run on the new TravisCI infrastructure.
 # See: http://docs.travis-ci.com/user/workers/container-based-infrastructure/
 sudo: false
 ## Cache composer
 cache:
  directories:
    - $HOME/.composer/cache
 matrix:
  include:
    - php: 5.5
      env: 'COMPOSER_FLAGS="--prefer-stable --prefer-lowest"'
 before_script:
  - travis_retry composer update ${COMPOSER_FLAGS} --no-interaction --prefer-dist
 script:
  - vendor/bin/phpcs --standard=psr2 src/
  - vendor/bin/phpunit --coverage-text --coverage-clover=coverage.clover
 after_script:
  - if [[ $TRAVIS_PHP_VERSION != 'hhvm' && $TRAVIS_PHP_VERSION != '7.0' ]]; then php vendor/bin/ocular code-coverage:upload --format=php-clover coverage.clover; fi
@@ -0,0 +1,21 @@
 # The MIT License (MIT)
 Copyright (c) 2016 Barry vd. Heuvel <barryvdh@gmail.com>
 > Permission is hereby granted, free of charge, to any person obtaining a copy
 > of this software and associated documentation files (the "Software"), to deal
 > in the Software without restriction, including without limitation the rights
 > to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 > copies of the Software, and to permit persons to whom the Software is
 > furnished to do so, subject to the following conditions:
 >
 > The above copyright notice and this permission notice shall be included in
 > all copies or substantial portions of the Software.
 >
 > THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 > IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 > FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 > AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 > LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 > OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 > THE SOFTWARE.
@@ -1,7 +1,7 @@
 {
    "name": "barryvdh/laravel-ide-helper",
    "description": "Laravel IDE Helper, generates correct PHPDocs for all Facade classes, to improve auto-completion.",
-    "keywords": ["laravel", "autocomplete", "phpstorm", "netbeans", "sublime", "codeintel", "phpdoc"],
+    "keywords": ["laravel", "autocomplete", "ide", "helper", "phpstorm", "netbeans", "sublime", "codeintel", "phpdoc"],
    "license": "MIT",
    "authors": [
        {
@@ -10,17 +10,39 @@
        }
    ],
    "require": {
-        "php": ">=5.3.0",
+        "php": ">=5.4.0",
-        "illuminate/support": "4.0.x",
+        "illuminate/support": "^5.0,<5.4",
-        "illuminate/console": "4.0.x",
+        "illuminate/console": "^5.0,<5.4",
-        "illuminate/filesystem": "4.0.x",
+        "illuminate/filesystem": "^5.0,<5.4",
-        "phpdocumentor/reflection-docblock": "dev-master#6d705c1a0f9e2a6d73d2e9ec0e538b9dfaf4315f",
+        "barryvdh/reflection-docblock": "^2.0.4",
-        "symfony/class-loader": "2.3.*"
+        "symfony/class-loader": "^2.3|^3.0"
    },
    "require-dev": {
        "phpunit/phpunit" : "4.*",
        "scrutinizer/ocular": "~1.1",
        "squizlabs/php_codesniffer": "~2.3",
        "doctrine/dbal": "~2.3"
    },
    "suggest": {
        "doctrine/dbal": "Load information from the database about models for phpdocs (~2.3)"
    },
    "autoload": {
-        "psr-0": {
+        "psr-4": {
-            "Barryvdh\\LaravelIdeHelper": "src/"
+            "Barryvdh\\LaravelIdeHelper\\": "src"
        }
    },
-    "minimum-stability": "dev"
+    "autoload-dev": {
        "psr-4": {
            ":vendor\\:package_name\\": "tests"
        }
    },
    "scripts": {
        "test": "phpunit",
        "cs": "phpcs --standard=psr2 src/"
    },
    "extra": {
        "branch-alias": {
            "dev-master": "2.2-dev"
        }
    }
 }
@@ -0,0 +1,168 @@
 <?php
 return array(
    /*
    |--------------------------------------------------------------------------
    | Filename & Format
    |--------------------------------------------------------------------------
    |
    | The default filename (without extension) and the format (php or json)
    |
    */
    'filename'  => '_ide_helper',
    'format'    => 'php',
    /*
    |--------------------------------------------------------------------------
    | Fluent helpers
    |--------------------------------------------------------------------------
    |
    | Set to true to generate commonly used Fluent methods
    |
    */
    'include_fluent' => false,
    /*
    |--------------------------------------------------------------------------
    | Helper files to include
    |--------------------------------------------------------------------------
    |
    | Include helper files. By default not included, but can be toggled with the
    | -- helpers (-H) option. Extra helper files can be included.
    |
    */
    'include_helpers' => false,
    'helper_files' => 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',
    ),
    /*
    |--------------------------------------------------------------------------
    | Extra classes
    |--------------------------------------------------------------------------
    |
    | These implementations are not really extended, but called with magic functions
    |
    */
    'extra' => array(
        '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',
        )
    ),
    /*
    |--------------------------------------------------------------------------
    | Interface implementations
    |--------------------------------------------------------------------------
    |
    | These interfaces will be replaced with the implementing class. Some interfaces
    | are detected by the helpers, others can be listed below.
    |
    */
    'interfaces' => array(
    ),
    /*
    |--------------------------------------------------------------------------
    | Support for custom DB types
    |--------------------------------------------------------------------------
    |
    | This setting allow you to map any custom database type (that you may have
    | created using CREATE TYPE statement or imported using database plugin
    | / extension to a Doctrine type.
    |
    | Each key in this array is a name of the Doctrine2 DBAL Platform. Currently valid names are:
    | 'postgresql', 'db2', 'drizzle', 'mysql', 'oracle', 'sqlanywhere', 'sqlite', 'mssql'
    |
    | This name is returned by getName() method of the specific Doctrine/DBAL/Platforms/AbstractPlatform descendant
    |
    | The value of the array is an array of type mappings. Key is the name of the custom type,
    | (for example, "jsonb" from Postgres 9.4) and the value is the name of the corresponding Doctrine2 type (in
    | our case it is 'json_array'. Doctrine types are listed here:
    | http://doctrine-dbal.readthedocs.org/en/latest/reference/types.html
    |
    | So to support jsonb in your models when working with Postgres, just add the following entry to the array below:
    |
    | "postgresql" => array(
    |       "jsonb" => "json_array",
    |  ),
    |
    */
    'custom_db_types' => array(
    ),
    /*
     |--------------------------------------------------------------------------
     | Support for camel cased models
     |--------------------------------------------------------------------------
     |
     | There are some Laravel packages (such as Eloquence) that allow for accessing
     | Eloquent model properties via camel case, instead of snake case.
     |
     | Enabling this option will support these packages by saving all model
     | properties as camel case, instead of snake case.
     |
     | For example, normally you would see this:
     |
     |  * @property \Carbon\Carbon $created_at
     |  * @property \Carbon\Carbon $updated_at
     |
     | With this enabled, the properties will be this:
     |
     |  * @property \Carbon\Carbon $createdAt
     |  * @property \Carbon\Carbon $updatedAt
     |
     | Note, it is currently an all-or-nothing option.
     |
     */
    'model_camel_case_properties' => false,
    /*
    |--------------------------------------------------------------------------
    | Property Casts
    |--------------------------------------------------------------------------
    |
    | Cast the given "real type" to the given "type".
    |
    */
   'type_overrides' => array(
        'integer' => 'int',
        'boolean' => 'bool',
   ),
 );
@@ -0,0 +1,29 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <phpunit bootstrap="vendor/autoload.php"
         backupGlobals="false"
         backupStaticAttributes="false"
         colors="true"
         verbose="true"
         convertErrorsToExceptions="true"
         convertNoticesToExceptions="true"
         convertWarningsToExceptions="true"
         processIsolation="false"
         stopOnFailure="false">
    <testsuites>
        <testsuite name=":vendor Test Suite">
            <directory>tests</directory>
        </testsuite>
    </testsuites>
    <filter>
        <whitelist>
            <directory suffix=".php">src/</directory>
        </whitelist>
    </filter>
    <logging>
        <log type="tap" target="build/report.tap"/>
        <log type="junit" target="build/report.junit.xml"/>
        <log type="coverage-html" target="build/coverage" charset="UTF-8" yui="true" highlight="true"/>
        <log type="coverage-text" target="build/coverage.txt"/>
        <log type="coverage-clover" target="build/logs/clover.xml"/>
    </logging>
 </phpunit>
@@ -1,79 +1,245 @@
-## Laravel IDE Helper Generator
+## Laravel 5 IDE Helper Generator
 [![Latest Version on Packagist][ico-version]][link-packagist]
 [![Software License][ico-license]](LICENSE.md)
 [![Build Status][ico-travis]][link-travis]
 [![Total Downloads][ico-downloads]][link-downloads]
 __For Laravel 4.x, check [version 1.11](https://github.com/barryvdh/laravel-ide-helper/tree/1.11)__
 ### 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.
+_Check out [this Laracasts video](https://laracasts.com/series/how-to-be-awesome-in-phpstorm/episodes/15) for a quick introduction/explanation!_
-* Netbeans and PHPStorm version: https://gist.github.com/barryvdh/5227822
+ * [`php artisan ide-helper:generate` - phpDoc generation for Laravel Facades ](#automatic-phpdoc-generation-for-laravel-facades)
-* SublimeText CodeIntel version: https://gist.github.com/barryvdh/5227814
+ * [`php artisan ide-helper:models` - phpDocs for models](#automatic-phpdocs-for-models)
 * [`php artisan ide-helper:meta` - PhpStorm Meta file](#phpstorm-meta-for-container-instances)
 This package generates a file that your IDE understands, so it can provide accurate autocompletion. Generation is done based on the files in your project, so they are always 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).
 * Generated version for L5: https://gist.github.com/barryvdh/5227822
 * Generated version for Lumen: https://gist.github.com/barryvdh/be17164b0ad51f832f20
 * Generated Phpstorm Meta file: https://gist.github.com/barryvdh/bb6ffc5d11e0a75dba67
 Note: You do need CodeIntel for Sublime Text: https://github.com/SublimeCodeIntel/SublimeCodeIntel
 ### Install
 Require this package with composer using the following command:
 ```bash
 composer require barryvdh/laravel-ide-helper
 ```
 After updating composer, add the service provider to the `providers` array in `config/app.php`
 ```php
 Barryvdh\LaravelIdeHelper\IdeHelperServiceProvider::class,
 ```
 To install this package on only development systems, add the `--dev` flag to your composer command:
 ```bash
 composer require --dev barryvdh/laravel-ide-helper
 ```
 In Laravel, instead of adding the service provider in the `config/app.php` file, you can add the following code to your `app/Providers/AppServiceProvider.php` file, within the `register()` method:
 ```php
 public function register()
 {
    if ($this->app->environment() !== 'production') {
        $this->app->register(\Barryvdh\LaravelIdeHelper\IdeHelperServiceProvider::class);
    }
    // ...
 }
 ```
 This will allow your application to load the Laravel IDE Helper on non-production enviroments.
 ### Automatic phpDoc generation for Laravel Facades
 #### NOTE: run before optimising. If bootstrap/compiled.php is loaded, it doesn't work.
-    php artisan clear-compiled
+You can now re-generate the docs yourself (for future updates)
    php artisan ide-helper:generate
    php artisan optimize
-Require this package in your composer.json:
+```bash
 php artisan ide-helper:generate
 ```
-    "barryvdh/laravel-ide-helper": "1.*"
+Note: `bootstrap/compiled.php` has to be cleared first, so run `php artisan clear-compiled` before generating (and `php artisan optimize` after).
 And add the ServiceProvider to the providers array in app/config/app.php
    'Barryvdh\LaravelIdeHelper\IdeHelperServiceProvider',
 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
    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":{
+```js
-        "post-update-cmd":[
+"scripts":{
-            "php artisan ide-helper:generate",
+    "post-update-cmd": [
-            "php artisan optimize"
+        "Illuminate\\Foundation\\ComposerScripts::postUpdate",
-        ]
+        "php artisan ide-helper:generate",
-    },
+        "php artisan ide-helper:meta",
        "php artisan optimize"
    ]
 },
 ```
-You can also publish the config-file to change implementations (ie. interface to specific class) or set defaults for --helpers or --sublime.
+You can also publish the config file to change implementations (ie. interface to specific class) or set defaults for `--helpers` or `--sublime`.
-    php artisan config:publish barryvdh/laravel-ide-helper
+```bash
 php artisan vendor:publish --provider="Barryvdh\LaravelIdeHelper\IdeHelperServiceProvider" --tag=config
 ```
 The generator tries to identify the real class, but if it cannot be found, you can define it in the config file.
-Some classes need a working database connection. If you do not have a working default connection, some facades will not be included.
+Some classes need a working database connection. If you do not have a default working connection, some facades will not be included.
-You can use a in-memory sqlite driver, using the -M option.
+You can use an in-memory SQLite driver by adding the -M option.
-You can choose to include helper files. This is not enabled by default, but you can override this with the --helpers (-H) option.
+You can choose to include helper files. This is not enabled by default, but you can override it with the `--helpers (-H)` option.
-The Illuminate/Support/helpers.php is already set-up, but you can add/remove your own files in the config file.
+The `Illuminate/Support/helpers.php` is already set up, but you can add/remove your own files in the config file.
 ### Automatic phpDocs for models
 > You need to require `doctrine/dbal: ~2.3` in your own composer.json to get database columns.
-### Work in progress: Model docs
+```bash
 composer require doctrine/dbal
 ```
-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 `php artisan ide-helper:models` to generate
-phpDocs, based on table columns, relations and getters/setters. Still in beta, so please provide feedback if you want.
+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)`.
-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.
+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, and only the newly found columns/relations are saved as phpdocs.
-You can now also write the comments directly to your Model file, using the -W argument. Please make sure to backup your models, before writing the info.
+```bash
-It should keep the existing comments and only append new properties/methods.
+php artisan ide-helper:models Post
 ```
-For now, only models in app/models are scanned. The optional argument tells what models to use (also outside app/models).
+```php
-`php artisan ide-helper:models Post,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
 */
 ```
-Note: With namespaces, uses \\ instead of \
+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 API\\User`
-This creates a file with the phpDocs for each Model. You should check and change them to be more accurate.
+```bash
-Also, all relations are Eloquent|Eloquent[] by default, you can change them to the actual Model.
+php artisan ide-helper:models Post User
-After copying the phpdocs to your model, you can clear the file, so your IDE only uses the real source.
+```
 You can also scan a different directory, using the `--dir` option (relative from the base path):
 ```bash
 php artisan ide-helper:models --dir="path/to/models" --dir="app/src/Model"
 ```
 You can publish the config file (`php artisan vendor:publish`) and set the default directories.
 Models can be ignored using the `--ignore (-I)` option
 ```bash
 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`)
 ## PhpStorm Meta for Container instances
 It's possible to generate a PhpStorm meta file to [add support for factory design pattern](https://confluence.jetbrains.com/display/PhpStorm/PhpStorm+Advanced+Metadata). For Laravel, this means we can make PhpStorm understand what kind of object we are resolving from the IoC Container. For example, `events` will return an `Illuminate\Events\Dispatcher` object, so with the meta file you can call `app('events')` and it will autocomplete the Dispatcher methods.
 ``` bash
 php artisan ide-helper:meta
 ```
 ```php
 app('events')->fire();
 \App::make('events')->fire();
 /** @var \Illuminate\Foundation\Application $app */
 $app->make('events')->fire();
 // When the key is not found, it uses the argument as class name
 app('App\SomeClass');
 ```
 Pre-generated example: https://gist.github.com/barryvdh/bb6ffc5d11e0a75dba67
 > Note: You might need to restart PhpStorm and make sure `.phpstorm.meta.php` is indexed.
 > Note: When you receive a FatalException about a class that is not found, check your config (for example, remove S3 as cloud driver when you don't have S3 configured. Remove Redis ServiceProvider when you don't use it).
 ## Lumen Install
 This pacakges is focused on Laravel development, but it can also be used in Lumen with some workarounds. Because Lumen works a little different, as it is like a barebone version of Laravel and the main configuration parameters are instead located in `bootstrap/app.php`, some arreglements must be made.
 #### Enabling Facades
 While Laravel IDE Helper can generate automatically default Facades for code hinting, Lumen doesn't come with Facades activated. If you plan in using them, you must enable them under the `Create The Application` section, uncommenting this line:
 ```php
 // $app->withFacades();
 ```
 From there, you should be able to use the `create_alias()` function to add additional Facades into your application.
 #### Adding the Service Provider
 You can install Laravel IDE Helper in `app/Providers/AppServiceProvider.php`, and uncommenting this line that registers the App Service Providers so it can properly load.
 ```php
 // $app->register(App\Providers\AppServiceProvider::class);
 ```
 If you are not using that line, that is usually handy to manage gracefully multiple Laravel/Lumen installations, you will have to add this line of code under the `Register Service Providers` section of your `bootstrap/app.php`.
 ```php
 if ($app->environment() !== 'production') {
    $app->register(\Barryvdh\LaravelIdeHelper\IdeHelperServiceProvider::class);
 }
 ```
 After that, Laravel IDE Helper should work correctly. During the generation process, the script may throw exceptions saying that some Classes doesn't exist or there are some undefined indexes. This is normal, as Lumen has some default packages stripped away, like Cookies, Storage and Session. If you plan to add these packages, you will have to add them manually and create additional 
 Facades if needed.
 #### Adding Additional Facades
 Currently Lumen IDE Helper doesn't take into account additional Facades created under `bootstrap/app.php` using `create_alias()`, so you need to create a `config/app.php` file and add your custom aliases under an `aliases` array again, like so:
 ```php
 return [
    'aliases' => [
        'CustomAliasOne' => Example\Support\Facades\CustomAliasOne::class,
        'CustomAliasTwo' => Example\Support\Facades\CustomAliasTwo::class,
        //...
    ]
 ];
 ```
 After you run ```php artisan ide-helper:generate```, it's recommended (but not mandatory) to rename `config/app.php` to something else until you have to re-generate the docs or after passing to production enviroment. Lumen 5.1+ will read this file for configuration parameters if it is present, and may overlap some configurations if it is completely populated.
 ### License
 The Laravel IDE Helper Generator is open-sourced software licensed under the [MIT license](http://opensource.org/licenses/MIT)
 [ico-version]: https://img.shields.io/packagist/v/barryvdh/laravel-ide-helper.svg?style=flat-square
 [ico-license]: https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square
 [ico-travis]: https://img.shields.io/travis/barryvdh/laravel-ide-helper/master.svg?style=flat-square
 [ico-scrutinizer]: https://img.shields.io/scrutinizer/coverage/g/barryvdh/laravel-ide-helper.svg?style=flat-square
 [ico-code-quality]: https://img.shields.io/scrutinizer/g/barryvdh/laravel-ide-helper.svg?style=flat-square
 [ico-downloads]: https://img.shields.io/packagist/dt/barryvdh/laravel-ide-helper.svg?style=flat-square
 [link-packagist]: https://packagist.org/packages/barryvdh/laravel-ide-helper
 [link-travis]: https://travis-ci.org/barryvdh/laravel-ide-helper
 [link-scrutinizer]: https://scrutinizer-ci.com/g/barryvdh/laravel-ide-helper/code-structure
 [link-code-quality]: https://scrutinizer-ci.com/g/barryvdh/laravel-ide-helper
 [link-downloads]: https://packagist.org/packages/barryvdh/laravel-ide-helper
 [link-author]: https://github.com/barryvdh
 [link-contributors]: ../../contributors
@@ -0,0 +1,66 @@
 <?= '<?php' ?>
 /**
 * A helper file for Laravel 5, to provide autocomplete information to your IDE
 * Generated for Laravel <?= $version ?> on <?= date("Y-m-d") ?>.
 *
 * @author Barry vd. Heuvel <[email protected]>
 * @see https://github.com/barryvdh/laravel-ide-helper
 */
 <?php foreach($namespaces as $namespace => $aliases): ?>
 namespace <?= $namespace == '__root' ? '' : $namespace ?>{
 <?php if($namespace == '__root'): ?>
    exit("This file should not be included, only analyzed by your IDE");
 <?= $helpers ?>
 <?php endif; ?>
 <?php foreach($aliases as $alias): ?>
    <?= $alias->getClassType() ?> <?= $alias->getShortName() ?> <?= $alias->getExtends() ? 'extends ' . $alias->getExtends() : '' ?>{
        <?php foreach($alias->getMethods() as $method): ?>
        <?= trim($method->getDocComment('        ')) ?>
        public static function <?= $method->getName() ?>(<?= $method->getParamsWithDefault() ?>){<?php if($method->getDeclaringClass() !== $method->getRoot()): ?>
            //Method inherited from <?= $method->getDeclaringClass() ?>
            <?php endif; ?>
            <?= $method->shouldReturn() ? 'return ': '' ?><?= $method->getRoot() ?>::<?= $method->getName() ?>(<?= $method->getParams() ?>);
        }
        <?php endforeach; ?>
    }
 <?php endforeach; ?>
 }
 <?php endforeach; ?>
 <?php if($include_fluent): ?>
 namespace Illuminate\Support {
    /**
     * Methods commonly used in migrations
     *
     * @method Fluent after(string $column) Add the after modifier
     * @method Fluent charset(string $charset) Add the character set modifier
     * @method Fluent collation(string $collation) Add the collation modifier
     * @method Fluent comment(string $comment) Add comment
     * @method Fluent default(mixed $value) Add the default modifier
     * @method Fluent first() Select first row
     * @method Fluent index(string $name = null) Add the in dex clause
     * @method Fluent on(string $column) `on` of a foreign key
     * @method Fluent onDelete(string $action) `on delete` of a foreign key
     * @method Fluent onUpdate(string $action) `on update` of a foreign key
     * @method Fluent primary() Add the primary key modifier
     * @method Fluent references(string $table) `references` of a foreign key
     * @method Fluent nullable() Add the nullable modifier
     * @method Fluent unique(string $name = null) Add unique index clause
     * @method Fluent unsigned() Add the unsigned modifier
     * @method Fluent useCurrent() Add the default timestamp value
     */
    class Fluent {}
 }
 <?php endif ?>
@@ -0,0 +1,21 @@
 <?= '<?php' ?>
 namespace PHPSTORM_META {
   /**
    * PhpStorm Meta file, to provide autocomplete information for PhpStorm
    * Generated on <?= date("Y-m-d") ?>.
    *
    * @author Barry vd. Heuvel <[email protected]>
    * @see https://github.com/barryvdh/laravel-ide-helper
    */
    $STATIC_METHOD_TYPES = [
 <?php foreach($methods as $method): ?>
        <?= $method ?> => [
            '' == '@',
 <?php foreach($bindings as $abstract => $class): ?>
            '<?= $abstract ?>' instanceof \<?= $class ?>,
 <?php endforeach ?>        ],
 <?php endforeach ?>
    ];
 }
@@ -0,0 +1,293 @@
 <?php
 /**
 * Laravel IDE Helper Generator
 *
 * @author    Barry vd. Heuvel <[email protected]>
 * @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;
 class Alias
 {
    protected $alias;
    protected $facade;
    protected $extends = null;
    protected $classType = 'class';
    protected $short;
    protected $namespace = '__root';
    protected $root = null;
    protected $classes = array();
    protected $methods = array();
    protected $usedMethods = array();
    protected $valid = false;
    protected $magicMethods = array();
    protected $interfaces = array();
    /**
     * @param string $alias
     * @param string $facade
     * @param array $magicMethods
     * @param array $interfaces
     */
    public function __construct($alias, $facade, $magicMethods = array(), $interfaces = array())
    {
        $this->alias = $alias;
        $this->magicMethods = $magicMethods;
        $this->interfaces = $interfaces;
        // Make the class absolute
        $facade = '\\' . ltrim($facade, '\\');
        $this->facade = $facade;
        $this->detectRoot();
        if ((!$this->isTrait() && $this->root)) {
            $this->valid = true;
        } else {
            return;
        }
        $this->addClass($this->root);
        $this->detectNamespace();
        $this->detectClassType();
        if ($facade === '\Illuminate\Database\Eloquent\Model') {
            $this->usedMethods = array('decrement', 'increment');
        }
    }
    /**
     * Add one or more classes to analyze
     *
     * @param array|string $classes
     */
    public function addClass($classes)
    {
        $classes = (array)$classes;
        foreach ($classes as $class) {
            if (class_exists($class) || interface_exists($class)) {
                $this->classes[] = $class;
            } else {
                echo "Class not exists: $class\r\n";
            }
        }
    }
    /**
     * Check if this class is valid to process.
     * @return bool
     */
    public function isValid()
    {
        return $this->valid;
    }
    /**
     * Get the classtype, 'interface' or 'class'
     *
     * @return string
     */
    public function getClasstype()
    {
        return $this->classType;
    }
    /**
     * Get the class which this alias extends
     *
     * @return null|string
     */
    public function getExtends()
    {
        return $this->extends;
    }
    /**
     * Get the Alias by which this class is called
     *
     * @return string
     */
    public function getAlias()
    {
        return $this->alias;
    }
    /**
     * Return the short name (without namespace)
     */
    public function getShortName()
    {
        return $this->short;
    }
    /**
     * Get the namespace from the alias
     *
     * @return string
     */
    public function getNamespace()
    {
        return $this->namespace;
    }
    /**
     * Get the methods found by this Alias
     *
     * @return array
     */
    public function getMethods()
    {
        $this->addMagicMethods();
        $this->detectMethods();
        return $this->methods;
    }
    /**
     * Detect the namespace
     */
    protected function detectNamespace()
    {
        if (strpos($this->alias, '\\')) {
            $nsParts = explode('\\', $this->alias);
            $this->short = array_pop($nsParts);
            $this->namespace = implode('\\', $nsParts);
        } else {
            $this->short = $this->alias;
        }
    }
    /**
     * Detect the class type
     */
    protected function detectClassType()
    {
        //Some classes extend the facade
        if (interface_exists($this->facade)) {
            $this->classType = 'interface';
            $this->extends = $this->facade;
        } else {
            $this->classType = 'class';
            if (class_exists($this->facade)) {
                $this->extends = $this->facade;
            }
        }
    }
    /**
     * Get the real root of a facade
     *
     * @return bool|string
     */
    protected function detectRoot()
    {
        $facade = $this->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)) {
                return;
            }
            $this->root = $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."
            );
        } catch (\Exception $e) {
            $this->error("Exception: " . $e->getMessage() . "\nSkipping $facade.");
        }
    }
    /**
     * Detect if this class is a trait or not.
     *
     * @return bool
     */
    protected function isTrait()
    {
        // Check if the facade is not a Trait
        if (function_exists('trait_exists') && trait_exists($this->facade)) {
            return true;
        }
        return false;
    }
    /**
     * Add magic methods, as defined in the configuration files
     */
    protected function addMagicMethods()
    {
        foreach ($this->magicMethods 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, $this->usedMethods)) {
                if ($class !== $this->root) {
                    $this->methods[] = new Method($method, $this->alias, $class, $magic, $this->interfaces);
                }
                $this->usedMethods[] = $magic;
            }
        }
    }
    /**
     * Get the methods for one or multiple classes.
     *
     * @return string
     */
    protected function detectMethods()
    {
        foreach ($this->classes as $class) {
            $reflection = new \ReflectionClass($class);
            $methods = $reflection->getMethods(\ReflectionMethod::IS_PUBLIC);
            if ($methods) {
                foreach ($methods as $method) {
                    if (!in_array($method->name, $this->usedMethods)) {
                        // Only add the methods to the output when the root is not the same as the class.
                        // And don't add the __*() methods
                        if ($this->extends !== $class && substr($method->name, 0, 2) !== '__') {
                            $this->methods[] = new Method(
                                $method,
                                $this->alias,
                                $reflection,
                                $method->name,
                                $this->interfaces
                            );
                        }
                        $this->usedMethods[] = $method->name;
                    }
                }
            }
        }
    }
    /**
     * Output an error.
     *
     * @param  string  $string
     * @return void
     */
    protected function error($string)
    {
        echo $string . "\r\n";
    }
 }
@@ -1,391 +0,0 @@
 <?php
 /**
 * Laravel IDE Helper Generator
 *
 * @author    Barry vd. Heuvel <[email protected]>
 * @copyright 2013 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 Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Input\InputArgument;
 use Illuminate\Foundation\AliasLoader;
 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
 *
 * @author Barry vd. Heuvel <[email protected]>
 */
 class GeneratorCommand extends Command {
    /**
     * The console command name.
     *
     * @var string
     */
    protected $name = 'ide-helper:generate';
    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Generate a new IDE Helper file.';
    protected $extra;
    protected $nonstatic;
    protected $onlyExtend;
    protected $helpers;
    protected $sublime;
    /**
     * Execute the console command.
     *
     * @return void
     */
    public function fire()
    {
        if (file_exists($compiled = base_path().'/bootstrap/compiled.php')){
            $this->error('Error: first delete bootstrap/compiled.php (php artisan clear-compiled)');
        }else{
            $filename = $this->argument('filename');
            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();
            }
            $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(){
        //Use a sqlite database in memory, to avoid connection errors on Database facades
        \Config::set('database.connections.sqlite',array(
                'driver'   => 'sqlite',
                'database' => ':memory:',
            ));
        \Config::set('database.default', 'sqlite');
    }
    /**
     * Get the console command arguments.
     *
     * @return array
     */
    protected function getArguments()
    {
        return array(
            array('filename', InputArgument::OPTIONAL, 'The path to the helper file', \Config::get('laravel-ide-helper::filename')),
        );
    }
    /**
     * Get the console command options.
     *
     * @return array
     */
    protected function getOptions()
    {
        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'),
        );
    }
    /**
     * Generate the docs for all facades in the AliasLoader
     *
     * @return string
     */
    protected function generateDocs(){
        $aliasLoader = AliasLoader::getInstance();
        $output = "<?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]>
 */
 namespace {\n\tdie('Only to be used as an helper for your IDE');\n}\n\n";
        $aliases = $aliasLoader->getAliases();
        foreach($aliases as $alias => $facade){
            try{
                if(method_exists($facade, 'getFacadeRoot')){
                    $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";
                if($root !== $facade or in_array($alias, $this->onlyExtend)){
                    //If the root class is not the same as the facade extend it.
                    $output .= " class $alias extends $facade{\n";
                }else{
                    $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();
                    if(array_key_exists($alias, $this->nonstatic) ){
                        $nonstaticMethods = $this->nonstatic[$alias];
                    }else{
                        $nonstaticMethods = array();
                    }
                    $methods = $reflection->getMethods(\ReflectionMethod::IS_PUBLIC);
                    if($methods)
                    {
                        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";
            }catch(\Exception $e){
                $this->error("Exception: ".$e->getMessage()."\nCould not analyze $root.");
            }
        }
        if(!empty($helpers)){
            foreach($helpers as $helper){
                if (file_exists($helper)){
                    $output .= str_replace(array('<?php', '?>'), '', \File::get($helper));
                }
            }
        }
        return $output;
    }
    /**
     * @param \ReflectionMethod $method
     * @param string $alias
     * @param string $root
     * @param bool $static
     * @param string $rootParam
     * @return string
     */
    protected function parseMethod($method, $alias, $root, $static = true, $rootParam = 'root'){
        $output = '';
        if($method->name === '__clone'){
            return $output;
        }
        $namespace = $method->getDeclaringClass()->getNamespaceName();
        $phpdoc = new DocBlock($method, new Context($namespace));
        $serializer = new DocBlockSerializer(1, "\t");
        $description = $phpdoc->getText();
        if(strpos($description, '{@inheritdoc}') !== false){
            $inheritdoc = $this->getInheritDoc($method);
            $inheritDescription = $inheritdoc->getText();
            $description = str_replace('{@inheritdoc}', $inheritDescription, $description);
            $phpdoc->setText($description);
            $inheritTags = $inheritdoc->getTags();
            if($inheritTags){
                foreach($inheritTags as $tag){
                    $tag->setDocBlock();
                    $phpdoc->appendTag($tag);
                }
            }
        }
        $phpdoc->appendTag(Tag::createInstance('@static', $phpdoc));
        //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..
        $paramTags = $phpdoc->getTagsByName('param');
        if($paramTags){
            /** @var  $tag */
            foreach($paramTags as $tag){
                $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;
        }
        $output .= $serializer->getDocComment($phpdoc) ."\n\t public ".($static ? 'static' : '')." function ".$method->name."(";
        $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;
        }
        $output .= implode($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;
    }
    /**
     * @param \ReflectionMethod $reflectionMethod
     * @return string
     */
    protected function getInheritDoc($reflectionMethod){
        $parentClass = $reflectionMethod->getDeclaringClass()->getParentClass();
        if($parentClass){
            $method = $parentClass->getMethod($reflectionMethod->getName());
        }else{
            $method = $reflectionMethod->getPrototype();
        }
        if($method){
            $phpdoc = new DocBlock($method);
            if(strpos($phpdoc->getText(), '{@inheritdoc}') !== false ){
                //Not at the end yet, try another parent/interface..
                return $this->getInheritDoc($method);
            }else{
                return $phpdoc;
            }
        }
    }
 }
@@ -1,65 +0,0 @@
 <?php
 /**
 * Laravel IDE Helper Generator
 *
 * @author    Barry vd. Heuvel <[email protected]>
 * @copyright 2013 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\Support\ServiceProvider;
 class IdeHelperServiceProvider extends ServiceProvider {
 	/**
 	 * Indicates if loading of the provider is deferred.
 	 *
 	 * @var bool
 	 */
 	protected $defer = false;
 	/**
 	 * Bootstrap the application events.
 	 *
 	 * @return void
 	 */
 	public function boot()
 	{
 		$this->package('barryvdh/laravel-ide-helper');
 	}
 	/**
 	 * Register the service provider.
 	 *
 	 * @return void
 	 */
 	public function register()
 	{
        $this->app['command.ide-helper.generate'] = $this->app->share(function($app)
        {
            return new GeneratorCommand;
        });
        $this->commands('command.ide-helper.generate');
        $this->app['command.ide-helper.models'] = $this->app->share(function($app)
            {
                return new ModelsCommand();
            });
        $this->commands('command.ide-helper.models');
 	}
 	/**
 	 * Get the services provided by the provider.
 	 *
 	 * @return array
 	 */
 	public function provides()
 	{
        return array('command.ide-helper.generate', 'command.ide-helper.models');
 	}
 }
@@ -1,378 +0,0 @@
 <?php
 /**
 * Laravel IDE Helper Generator
 *
 * @author    Barry vd. Heuvel <[email protected]>
 * @copyright 2013 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 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
 *
 * @author Barry vd. Heuvel <[email protected]>
 */
 class ModelsCommand extends Command {
    /**
     * The console command name.
     *
     * @var string
     */
    protected $name = 'ide-helper:models';
    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Generate autocompletion for models';
    protected $properties = array();
    protected $methods = array();
    protected $write = false;
    /**
     * Execute the console command.
     *
     * @return void
     */
    public function fire()
    {
        $filename = $this->option('filename');
        $this->write = $this->option('write');
        $model = $this->argument('model');
        $content = $this->generateDocs($model);
        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");
            }
        }
    }
    /**
     * Get the console command arguments.
     *
     * @return array
     */
    protected function getArguments()
    {
        return array(
            array('model', InputArgument::OPTIONAL, 'Which models to include', '*'),
        );
    }
    /**
     * Get the console command options.
     *
     * @return array
     */
    protected function getOptions()
    {
        return array(
            array('filename', 'F', InputOption::VALUE_OPTIONAL, 'The path to the helper file', '_ide_helper_models.php'),
            array('write', 'W', InputOption::VALUE_NONE, 'Write to Model file'),
        );
    }
    protected function generateDocs($model){
        $output = "<?php
 /**
 * An helper file for your Eloquent Models
 * Copy the phpDocs from this file to the correct Model,
 * And remove them from this file, to prevent double declarations.
 *
 * @author Barry vd. Heuvel <[email protected]>
 */
 \n\n";
        if($model === '*'){
            $models = $this->loadModels();
        }else{
            $models = explode(',', $model);
        }
        foreach($models as $name){
            $this->properties = array();
            $this->methods = array();
            if(class_exists($name)){
                try{
                    $model = new $name();
                    $this->getPropertiesFromTable($model);
                    $this->getPropertiesFromMethods($model);
                    $output .= $this->createPhpDocs($name);
                }catch(\Exception $e){
                    $this->error("Exception: ".$e->getMessage()."\nCould not analyze class $name.");
                }
            }else{
                $this->error("Class $name does not exist");
            }
        }
        return $output;
    }
    protected function loadModels(){
        $models = array();
        foreach(ClassMapGenerator::createMap(app_path().'/models') 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);
        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':
                        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;
                }
                $this->setProperty($name, $type, true, true);
            }
        }
    }
    /**
     * @param \Illuminate\Database\Eloquent\Model $model
     */
    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)){
                        $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)){
                        $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')){
                   //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);
                   $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
                   }
               }
           }
        }
    }
    /**
     * @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();
            $this->properties[$name]['type'] = 'mixed';
            $this->properties[$name]['read'] = false;
            $this->properties[$name]['write'] = false;
        }
        if($type !== null){
            $this->properties[$name]['type'] = $type;
        }
        if($read !== null){
            $this->properties[$name]['read'] = $read;
        }
        if($write !== null){
            $this->properties[$name]['write'] = $write;
        }
    }
    protected function setMethod($name, $type = null){
        if(!isset($this->methods[$name])){
            $this->methods[$name] = array();
            $this->methods[$name]['type'] = 'static';
        }
        if($type !== null){
            $this->methods[$name]['type'] = $type;
        }
    }
    /**
     * @param string $class
     * @return string
     */
    protected function createPhpDocs($class){
        $reflection = new \ReflectionClass($class);
        $namespace = $reflection->getNamespaceName();
        $originalDoc = $reflection->getDocComment();
        $phpdoc = new DocBlock($reflection, new Context($namespace));
        if(!$phpdoc->getText()){
            $phpdoc->setText("Generated properties for $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']){
                $attr = 'property-write';
            }else{
                $attr = 'property-read';
            }
            $tag = Tag::createInstance("@{$attr} {$property['type']} {$name}", $phpdoc);
            $phpdoc->appendTag($tag);
        }
        foreach($this->methods as $name => $method){
            if(in_array($name, $methods)){
                continue;
            }
            $name = "$name()";
            $tag = Tag::createInstance("@method {$method['type']} {$name}", $phpdoc);
            $phpdoc->appendTag($tag);
        }
        $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 {$class}";
                $replace = "{$docComment}\nclass {$class}";
                $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 {$class} {}\n}\n\n";
        return $output;
    }
 }
@@ -0,0 +1,169 @@
 <?php
 /**
 * Laravel IDE Helper Generator
 *
 * @author    Barry vd. Heuvel <[email protected]>
 * @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\Console;
 use Barryvdh\LaravelIdeHelper\Generator;
 use Illuminate\Config\Repository as ConfigRepository;
 use Illuminate\Console\Command;
 use Illuminate\Filesystem\Filesystem;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Input\InputArgument;
 /**
 * A command to generate autocomplete information for your IDE
 *
 * @author Barry vd. Heuvel <[email protected]>
 */
 class GeneratorCommand extends Command
 {
    /**
     * The console command name.
     *
     * @var string
     */
    protected $name = 'ide-helper:generate';
    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Generate a new IDE Helper file.';
    /** @var \Illuminate\Config\Repository */
    protected $config;
    /** @var \Illuminate\Filesystem\Filesystem */
    protected $files;
    /** @var \Illuminate\View\Factory */
    protected $view;
    protected $onlyExtend;
    /**
     *
     * @param \Illuminate\Config\Repository $config
     * @param \Illuminate\Filesystem\Filesystem $files
     * @param \Illuminate\View\Factory $view
     */
    public function __construct(
        /*ConfigRepository */ $config,
        Filesystem $files,
        /* Illuminate\View\Factory */
        $view
    ) {
        $this->config = $config;
        $this->files = $files;
        $this->view = $view;
        parent::__construct();
    }
    /**
     * Execute the console command.
     *
     * @return void
     */
    public function fire()
    {
        if (file_exists(base_path() . '/vendor/compiled.php') ||
            file_exists(base_path() . '/bootstrap/cache/compiled.php') ||
            file_exists(base_path() . '/storage/framework/compiled.php')) {
            $this->error(
                'Error generating IDE Helper: first delete your compiled file (php artisan clear-compiled)'
            );
        } else {
            $filename = $this->argument('filename');
            $format = $this->option('format');
            // Strip the php extension
            if (substr($filename, -4, 4) == '.php') {
                $filename = substr($filename, 0, -4);
            }
            $filename .= '.' . $format;
            if ($this->option('memory')) {
                $this->useMemoryDriver();
            }
            $helpers = '';
            if ($this->option('helpers') || ($this->config->get('ide-helper.include_helpers'))) {
                foreach ($this->config->get('ide-helper.helper_files', array()) as $helper) {
                    if (file_exists($helper)) {
                        $helpers .= str_replace(array('<?php', '?>'), '', $this->files->get($helper));
                    }
                }
            } else {
                $helpers = '';
            }
            $generator = new Generator($this->config, $this->view, $this->getOutput(), $helpers);
            $content = $generator->generate($format);
            $written = $this->files->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()
    {
        //Use a sqlite database in memory, to avoid connection errors on Database facades
        $this->config->set(
            'database.connections.sqlite',
            array(
                'driver' => 'sqlite',
                'database' => ':memory:',
            )
        );
        $this->config->set('database.default', 'sqlite');
    }
    /**
     * Get the console command arguments.
     *
     * @return array
     */
    protected function getArguments()
    {
        $filename = $this->config->get('ide-helper.filename');
        return array(
            array(
                'filename', InputArgument::OPTIONAL, 'The path to the helper file', $filename
            ),
        );
    }
    /**
     * Get the console command options.
     *
     * @return array
     */
    protected function getOptions()
    {
        $format = $this->config->get('ide-helper.format');
        return array(
            array('format', "F", InputOption::VALUE_OPTIONAL, 'The format for the IDE Helper', $format),
            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'),
        );
    }
 }
@@ -0,0 +1,142 @@
 <?php
 /**
 * Laravel IDE Helper Generator
 *
 * @author    Barry vd. Heuvel <[email protected]>
 * @copyright 2015 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\Console;
 use Illuminate\Console\Command;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
 /**
 * A command to generate phpstorm meta data
 *
 * @author Barry vd. Heuvel <[email protected]>
 */
 class MetaCommand extends Command
 {
    /**
     * The console command name.
     *
     * @var string
     */
    protected $name = 'ide-helper:meta';
    protected $filename = '.phpstorm.meta.php';
    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Generate metadata for PhpStorm';
    /** @var \Illuminate\Contracts\Filesystem\Filesystem */
    protected $files;
    /** @var \Illuminate\Contracts\View\Factory */
    protected $view;
    protected $methods = [
      'new \Illuminate\Contracts\Container\Container',
      '\Illuminate\Contracts\Container\Container::make(\'\')',
      '\App::make(\'\')',
      '\app(\'\')',
    ];
    /**
     *
     * @param \Illuminate\Contracts\Filesystem\Filesystem $files
     * @param \Illuminate\Contracts\View\Factory $view
     */
    public function __construct($files, $view)
    {
        $this->files = $files;
        $this->view = $view;
        parent::__construct();
    }
    /**
     * Execute the console command.
     *
     * @return void
     */
    public function fire()
    {
        $this->registerClassAutoloadExceptions();
        $bindings = array();
        foreach ($this->getAbstracts() as $abstract) {
            // Validator and seeder cause problems
            if (in_array($abstract, ['validator', 'seeder'])) {
                continue;
            }
            try {
                $concrete = $this->laravel->make($abstract);
                if (is_object($concrete)) {
                    $bindings[$abstract] = get_class($concrete);
                }
            } catch (\Exception $e) {
                if ($this->output->getVerbosity() >= OutputInterface::VERBOSITY_VERBOSE) {
                    $this->comment("Cannot make '$abstract': ".$e->getMessage());
                }
            }
        }
        $content = $this->view->make('ide-helper::meta', [
          'bindings' => $bindings,
          'methods' => $this->methods,
        ])->render();
        $filename = $this->option('filename');
        $written = $this->files->put($filename, $content);
        if ($written !== false) {
            $this->info("A new meta file was written to $filename");
        } else {
            $this->error("The meta file could not be created at $filename");
        }
    }
    /**
     * Get a list of abstracts from the Laravel Application.
     *
     * @return array
     */
    protected function getAbstracts()
    {
        $abstracts = $this->laravel->getBindings();
        // Return the abstract names only
        return array_keys($abstracts);
    }
    /**
     * Register an autoloader the throws exceptions when a class is not found.
     */
    protected function registerClassAutoloadExceptions()
    {
        spl_autoload_register(function ($class) {
            throw new \Exception("Class '$class' not found.");
        });
    }
    /**
     * Get the console command options.
     *
     * @return array
     */
    protected function getOptions()
    {
        return array(
            array('filename', 'F', InputOption::VALUE_OPTIONAL, 'The path to the meta file', $this->filename),
        );
    }
 }
@@ -0,0 +1,694 @@
 <?php
 /**
 * Laravel IDE Helper Generator
 *
 * @author    Barry vd. Heuvel <[email protected]>
 * @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\Console;
 use Illuminate\Console\Command;
 use Illuminate\Database\Eloquent\Relations\Relation;
 use Illuminate\Support\Str;
 use Illuminate\Filesystem\Filesystem;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Output\OutputInterface;
 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;
 /**
 * A command to generate autocomplete information for your IDE
 *
 * @author Barry vd. Heuvel <[email protected]>
 */
 class ModelsCommand extends Command
 {
    /**
     * @var Filesystem $files
     */
    protected $files;
    /**
     * The console command name.
     *
     * @var string
     */
    protected $name = 'ide-helper:models';
    protected $filename = '_ide_helper_models.php';
    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Generate autocompletion for models';
    protected $properties = array();
    protected $methods = array();
    protected $write = false;
    protected $dirs = array();
    protected $reset;
    /**
     * @param Filesystem $files
     */
    public function __construct(Filesystem $files)
    {
        parent::__construct();
        $this->files = $files;
    }
    /**
     * Execute the console command.
     *
     * @return void
     */
    public function fire()
    {
        $filename = $this->option('filename');
        $this->write = $this->option('write');
        $this->dirs = array_merge(
            $this->laravel['config']->get('ide-helper.model_locations'),
            $this->option('dir')
        );
        $model = $this->argument('model');
        $ignore = $this->option('ignore');
        $this->reset = $this->option('reset');
        //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 = $this->files->put($filename, $content);
            if ($written !== false) {
                $this->info("Model information was written to $filename");
            } else {
                $this->error("Failed to write model information to $filename");
            }
        }
    }
    /**
     * Get the console command arguments.
     *
     * @return array
     */
    protected function getArguments()
    {
        return array(
          array('model', InputArgument::OPTIONAL | InputArgument::IS_ARRAY, 'Which models to include', array()),
        );
    }
    /**
     * Get the console command options.
     *
     * @return array
     */
    protected function getOptions()
    {
        return array(
          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($loadModels, $ignore = '')
    {
        $output = "<?php
 /**
 * A helper file for your Eloquent Models
 * Copy the phpDocs from this file to the correct Model,
 * And remove them from this file, to prevent double declarations.
 *
 * @author Barry vd. Heuvel <[email protected]>
 */
 \n\n";
        $hasDoctrine = interface_exists('Doctrine\DBAL\Driver');
        if (empty($loadModels)) {
            $models = $this->loadModels();
        } else {
            $models = array();
            foreach ($loadModels as $model) {
                $models = array_merge($models, explode(',', $model));
            }
        }
        $ignore = explode(',', $ignore);
        foreach ($models as $name) {
            if (in_array($name, $ignore)) {
                if ($this->output->getVerbosity() >= OutputInterface::VERBOSITY_VERBOSE) {
                    $this->comment("Ignoring model '$name'");
                }
                continue;
            }
            $this->properties = array();
            $this->methods = array();
            if (class_exists($name)) {
                try {
                    // handle abstract classes, interfaces, ...
                    $reflectionClass = new \ReflectionClass($name);
                    if (!$reflectionClass->isSubclassOf('Illuminate\Database\Eloquent\Model')) {
                        continue;
                    }
                    if ($this->output->getVerbosity() >= OutputInterface::VERBOSITY_VERBOSE) {
                        $this->comment("Loading model '$name'");
                    }
                    if (!$reflectionClass->IsInstantiable()) {
                        // ignore abstract class or interface
                        continue;
                    }
                    $model = $this->laravel->make($name);
                    if ($hasDoctrine) {
                        $this->getPropertiesFromTable($model);
                    }
                    if (method_exists($model, 'getCasts')) {
                        $this->castPropertiesType($model);
                    }
                    $this->getPropertiesFromMethods($model);
                    $output .= $this->createPhpDocs($name);
                    $ignore[] = $name;
                } catch (\Exception $e) {
                    $this->error("Exception: " . $e->getMessage() . "\nCould not analyze class $name.");
                }
            }
        }
        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;
    }
    protected function loadModels()
    {
        $models = array();
        foreach ($this->dirs as $dir) {
            $dir = base_path() . '/' . $dir;
            if (file_exists($dir)) {
                foreach (ClassMapGenerator::createMap($dir) as $model => $path) {
                    $models[] = $model;
                }
            }
        }
        return $models;
    }
    /**
     * cast the properties's type from $casts.
     *
     * @param \Illuminate\Database\Eloquent\Model $model
     */
    protected function castPropertiesType($model)
    {
        $casts = $model->getCasts();
        foreach ($casts as $name => $type) {
            switch ($type) {
                case 'boolean':
                case 'bool':
                    $realType = 'boolean';
                    break;
                case 'string':
                    $realType = 'string';
                    break;
                case 'array':
                case 'json':
                    $realType = 'array';
                    break;
                case 'object':
                    $realType = 'object';
                    break;
                case 'int':
                case 'integer':
                case 'timestamp':
                    $realType = 'integer';
                    break;
                case 'real':
                case 'double':
                case 'float':
                    $realType = 'float';
                    break;
                case 'date':
                case 'datetime':
                    $realType = '\Carbon\Carbon';
                    break;
                case 'collection':
                    $realType = '\Illuminate\Support\Collection';
                    break;
                default:
                    $realType = 'mixed';
                    break;
            }
            if (!isset($this->properties[$name])) {
                continue;
            } else {
                $this->properties[$name]['type'] = $this->getTypeOverride($realType);
            }
        }
    }
    /**
     * Returns the overide type for the give type.
     *
     * @param string $type
     * @return string
     */
    protected function getTypeOverride($type)
    {
        $typeOverrides = $this->laravel['config']->get('ide-helper.type_overrides', array());
        return isset($typeOverrides[$type]) ? $typeOverrides[$type] : $type;
    }
    /**
     * Load the properties from the database table.
     *
     * @param \Illuminate\Database\Eloquent\Model $model
     */
    protected function getPropertiesFromTable($model)
    {
        $table = $model->getConnection()->getTablePrefix() . $model->getTable();
        $schema = $model->getConnection()->getDoctrineSchemaManager($table);
        $databasePlatform = $schema->getDatabasePlatform();
        $databasePlatform->registerDoctrineTypeMapping('enum', 'string');
        $platformName = $databasePlatform->getName();
        $customTypes = $this->laravel['config']->get("ide-helper.custom_db_types.{$platformName}", array());
        foreach ($customTypes as $yourTypeName => $doctrineTypeName) {
            $databasePlatform->registerDoctrineTypeMapping($yourTypeName, $doctrineTypeName);
        }
        $database = null;
        if (strpos($table, '.')) {
            list($database, $table) = explode('.', $table);
        }
        $columns = $schema->listTableColumns($table, $database);
        if ($columns) {
            foreach ($columns as $column) {
                $name = $column->getName();
                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;
                        default:
                            $type = 'mixed';
                            break;
                    }
                }
                $comment = $column->getComment();
                $this->setProperty($name, $type, true, true, $comment);
                $this->setMethod(
                    Str::camel("where_" . $name),
                    '\Illuminate\Database\Query\Builder|\\' . get_class($model),
                    array('$value')
                );
            }
        }
    }
    /**
     * @param \Illuminate\Database\Eloquent\Model $model
     */
    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 !== 'getAttribute'
                ) {
                    //Magic get<name>Attribute
                    $name = Str::snake(substr($method, 3, -9));
                    if (!empty($name)) {
                        $reflection = new \ReflectionMethod($model, $method);
                        $type = $this->getReturnTypeFromDocBlock($reflection);
                        $this->setProperty($name, $type, 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)) {
                        $this->setProperty($name, null, null, true);
                    }
                } 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, '\Illuminate\Database\Query\Builder|\\' . $reflection->class, $args);
                    }
                } 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);
                    $file = new \SplFileObject($reflection->getFileName());
                    $file->seek($reflection->getStartLine() - 1);
                    $code = '';
                    while ($file->key() < $reflection->getEndLine()) {
                        $code .= $file->current();
                        $file->next();
                    }
                    $code = trim(preg_replace('/\s\s+/', '', $code));
                    $begin = strpos($code, 'function(');
                    $code = substr($code, $begin, strrpos($code, '}') - $begin + 1);
                    foreach (array(
                               'hasMany',
                               'hasManyThrough',
                               'belongsToMany',
                               'hasOne',
                               'belongsTo',
                               'morphOne',
                               'morphTo',
                               'morphMany',
                               'morphToMany'
                             ) as $relation) {
                        $search = '$this->' . $relation . '(';
                        if ($pos = stripos($code, $search)) {
                            //Resolve the relation's model to a Relation object.
                            $relationObj = $model->$method();
                            if ($relationObj instanceof Relation) {
                                $relatedModel = '\\' . get_class($relationObj->getRelated());
                                $relations = ['hasManyThrough', 'belongsToMany', 'hasMany', 'morphMany', 'morphToMany'];
                                if (in_array($relation, $relations)) {
                                    //Collection or array of models (because Collection is Arrayable)
                                    $this->setProperty(
                                        $method,
                                        $this->getCollectionClass($relatedModel) . '|' . $relatedModel . '[]',
                                        true,
                                        null
                                    );
                                } elseif ($relation === "morphTo") {
                                    // Model isn't specified because relation is polymorphic
                                    $this->setProperty(
                                        $method,
                                        '\Illuminate\Database\Eloquent\Model|\Eloquent',
                                        true,
                                        null
                                    );
                                } else {
                                    //Single model is returned
                                    $this->setProperty($method, $relatedModel, true, null);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    /**
     * @param string $name
     * @param string|null $type
     * @param bool|null $read
     * @param bool|null $write
     * @param string|null $comment
     */
    protected function setProperty($name, $type = null, $read = null, $write = null, $comment = '')
    {
        if (!isset($this->properties[$name])) {
            $this->properties[$name] = array();
            $this->properties[$name]['type'] = 'mixed';
            $this->properties[$name]['read'] = false;
            $this->properties[$name]['write'] = false;
            $this->properties[$name]['comment'] = (string) $comment;
        }
        if ($type !== null) {
            $this->properties[$name]['type'] = $this->getTypeOverride($type);
        }
        if ($read !== null) {
            $this->properties[$name]['read'] = $read;
        }
        if ($write !== null) {
            $this->properties[$name]['write'] = $write;
        }
    }
    protected function setMethod($name, $type = '', $arguments = array())
    {
        $methods = array_change_key_case($this->methods, CASE_LOWER);
        if (!isset($methods[strtolower($name)])) {
            $this->methods[$name] = array();
            $this->methods[$name]['type'] = $type;
            $this->methods[$name]['arguments'] = $arguments;
        }
    }
    /**
     * @param string $class
     * @return string
     */
    protected function createPhpDocs($class)
    {
        $reflection = new \ReflectionClass($class);
        $namespace = $reflection->getNamespaceName();
        $classname = $reflection->getShortName();
        $originalDoc = $reflection->getDocComment();
        if ($this->reset) {
            $phpdoc = new DocBlock('', new Context($namespace));
        } else {
            $phpdoc = new DocBlock($reflection, new Context($namespace));
        }
        if (!$phpdoc->getText()) {
            $phpdoc->setText($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']) {
                $attr = 'property-write';
            } else {
                $attr = 'property-read';
            }
            if ($this->hasCamelCaseModelProperties()) {
                $name = Str::camel($name);
            }
            $tagLine = trim("@{$attr} {$property['type']} {$name} {$property['comment']}");
            $tag = Tag::createInstance($tagLine, $phpdoc);
            $phpdoc->appendTag($tag);
        }
        foreach ($this->methods as $name => $method) {
            if (in_array($name, $methods)) {
                continue;
            }
            $arguments = implode(', ', $method['arguments']);
            $tag = Tag::createInstance("@method static {$method['type']} {$name}({$arguments})", $phpdoc);
            $phpdoc->appendTag($tag);
        }
        if ($this->write && ! $phpdoc->getTagsByName('mixin')) {
            $phpdoc->appendTag(Tag::createInstance("@mixin \\Eloquent", $phpdoc));
        }
        $serializer = new DocBlockSerializer();
        $serializer->getDocComment($phpdoc);
        $docComment = $serializer->getDocComment($phpdoc);
        if ($this->write) {
            $filename = $reflection->getFileName();
            $contents = $this->files->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 ($this->files->put($filename, $contents)) {
                $this->info('Written new phpDocBlock to ' . $filename);
            }
        }
        $output = "namespace {$namespace}{\n{$docComment}\n\tclass {$classname} extends \Eloquent {}\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();
        /** @var \ReflectionParameter $param */
        foreach ($method->getParameters() as $param) {
            $paramClass = $param->getClass();
            $paramStr = (!is_null($paramClass) ? '\\' . $paramClass->getName() . ' ' : '') . '$' . $param->getName();
            $params[] = $paramStr;
            if ($param->isOptional() && $param->isDefaultValueAvailable()) {
                $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;
    }
    /**
     * Determine a model classes' collection type.
     *
     * @see http://laravel.com/docs/eloquent-collections#custom-collections
     * @param string $className
     * @return string
     */
    private function getCollectionClass($className)
    {
        // Return something in the very very unlikely scenario the model doesn't
        // have a newCollection() method.
        if (!method_exists($className, 'newCollection')) {
            return '\Illuminate\Database\Eloquent\Collection';
        }
        /** @var \Illuminate\Database\Eloquent\Model $model */
        $model = new $className;
        return '\\' . get_class($model->newCollection());
    }
    /**
     * @return bool
     */
    protected function hasCamelCaseModelProperties()
    {
        return $this->laravel['config']->get('ide-helper.model_camel_case_properties', false);
    }
    /**
     * Get method return type based on it DocBlock comment
     *
     * @param \ReflectionMethod $reflection
     *
     * @return null|string
     */
    protected function getReturnTypeFromDocBlock(\ReflectionMethod $reflection)
    {
        $type = null;
        $phpdoc = new DocBlock($reflection);
        if ($phpdoc->hasTag('return')) {
            $type = $phpdoc->getTagsByName('return')[0]->getContent();
        }
        return $type;
    }
 }
@@ -0,0 +1,302 @@
 <?php
 /**
 * Laravel IDE Helper Generator
 *
 * @author    Barry vd. Heuvel <[email protected]>
 * @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\Foundation\Application;
 use Illuminate\Foundation\AliasLoader;
 use Illuminate\Config\Repository as ConfigRepository;
 use ReflectionClass;
 use Symfony\Component\Console\Output\OutputInterface;
 class Generator
 {
    /** @var \Illuminate\Config\Repository */
    protected $config;
    /** @var \Illuminate\View\Factory */
    protected $view;
    /** @var \Symfony\Component\Console\Output\OutputInterface */
    protected $output;
    protected $extra = array();
    protected $magic = array();
    protected $interfaces = array();
    protected $helpers;
    /**
     * @param \Illuminate\Config\Repository $config
     * @param \Illuminate\View\Factory $view
     * @param \Symfony\Component\Console\Output\OutputInterface $output
     * @param string $helpers
     */
    public function __construct(
        /*ConfigRepository */ $config,
        /* Illuminate\View\Factory */ $view,
        OutputInterface $output = null,
        $helpers = ''
    ) {
        $this->config = $config;
        $this->view = $view;
        // Find the drivers to add to the extra/interfaces
        $this->detectDrivers();
        $this->extra = array_merge($this->extra, $this->config->get('ide-helper.extra'));
        $this->magic = array_merge($this->magic, $this->config->get('ide-helper.magic'));
        $this->interfaces = array_merge($this->interfaces, $this->config->get('ide-helper.interfaces'));
        // Make all interface classes absolute
        foreach ($this->interfaces as &$interface) {
            $interface = '\\' . ltrim($interface, '\\');
        }
        $this->helpers = $helpers;
    }
    /**
     * Generate the helper file contents;
     *
     * @param  string  $format  The format to generate the helper in (php/json)
     * @return string;
     */
    public function generate($format = 'php')
    {
        // Check if the generator for this format exists
        $method = 'generate'.ucfirst($format).'Helper';
        if (method_exists($this, $method)) {
            return $this->$method();
        }
        return $this->generatePhpHelper();
    }
    public function generatePhpHelper()
    {
        $app = app();
        return $this->view->make('ide-helper::helper')
            ->with('namespaces', $this->getNamespaces())
            ->with('helpers', $this->helpers)
            ->with('version', $app->version())
            ->with('include_fluent', $this->config->get('ide-helper.include_fluent', false))
            ->render();
    }
    public function generateJsonHelper()
    {
        $classes = array();
        foreach ($this->getNamespaces() as $aliases) {
            foreach ($aliases as $alias) {
                $functions = array();
                foreach ($alias->getMethods() as $method) {
                    $functions[$method->getName()] = '('. $method->getParamsWithDefault().')';
                }
                $classes[$alias->getAlias()] = array(
                    'functions' => $functions,
                );
            }
        }
        $flags = JSON_FORCE_OBJECT;
        if (defined('JSON_PRETTY_PRINT')) {
            $flags |= JSON_PRETTY_PRINT;
        }
        return json_encode(array(
            'php' => array(
                'classes' => $classes,
            ),
        ), $flags);
    }
    protected function detectDrivers()
    {
        $defaultUserModel = config('auth.providers.users.model', config('auth.model', 'App\User'));
        $this->interfaces['\Illuminate\Contracts\Auth\Authenticatable'] = $defaultUserModel;
        try {
            if (class_exists('Auth') && is_a('Auth', '\Illuminate\Support\Facades\Auth', true)) {
                if (class_exists('\Illuminate\Foundation\Application')) {
                    $authMethod = version_compare(Application::VERSION, '5.2', '>=') ? 'guard' : 'driver';
                } else {
                    $refClass = new ReflectionClass('\Laravel\Lumen\Application');
                    $versionStr = $refClass->newInstanceWithoutConstructor()->version();
                    $authMethod = strpos($versionStr, 'Lumen (5.0') === 0 ?
                        'driver' :
                        (strpos($versionStr, 'Lumen (5.1') === 0 ? 'driver' : 'guard');
                }
                $class = get_class(\Auth::$authMethod());
                $this->extra['Auth'] = array($class);
                $this->interfaces['\Illuminate\Auth\UserProviderInterface'] = $class;
            }
        } catch (\Exception $e) {
        }
        try {
            if (class_exists('DB') && is_a('DB', '\Illuminate\Support\Facades\DB', true)) {
                $class = get_class(\DB::connection());
                $this->extra['DB'] = array($class);
                $this->interfaces['\Illuminate\Database\ConnectionInterface'] = $class;
            }
        } catch (\Exception $e) {
        }
        try {
            if (class_exists('Cache') && is_a('Cache', '\Illuminate\Support\Facades\Cache', true)) {
                $driver = get_class(\Cache::driver());
                $store = get_class(\Cache::getStore());
                $this->extra['Cache'] = array($driver, $store);
                $this->interfaces['\Illuminate\Cache\StoreInterface'] = $store;
            }
        } catch (\Exception $e) {
        }
        try {
            if (class_exists('Queue') && is_a('Queue', '\Illuminate\Support\Facades\Queue', true)) {
                $class = get_class(\Queue::connection());
                $this->extra['Queue'] = array($class);
                $this->interfaces['\Illuminate\Queue\QueueInterface'] = $class;
            }
        } catch (\Exception $e) {
        }
        try {
            if (class_exists('SSH') && is_a('SSH', '\Illuminate\Support\Facades\SSH', true)) {
                $class = get_class(\SSH::connection());
                $this->extra['SSH'] = array($class);
                $this->interfaces['\Illuminate\Remote\ConnectionInterface'] = $class;
            }
        } catch (\Exception $e) {
        }
        try {
            if (class_exists('Storage') && is_a('Storage', '\Illuminate\Support\Facades\Storage', true)) {
                $class = get_class(\Storage::disk());
                $this->extra['Storage'] = array($class);
                $this->interfaces['\Illuminate\Contracts\Filesystem\Filesystem'] = $class;
            }
        } catch (\Exception $e) {
        }
    }
    /**
     * Find all namespaces/aliases that are valid for us to render
     *
     * @return array
     */
    protected function getNamespaces()
    {
        $namespaces = array();
        // 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')) {
                continue;
            }
            $magicMethods = array_key_exists($name, $this->magic) ? $this->magic[$name] : array();
            $alias = new Alias($name, $facade, $magicMethods, $this->interfaces);
            if ($alias->isValid()) {
                //Add extra methods, from other classes (magic static calls)
                if (array_key_exists($name, $this->extra)) {
                    $alias->addClass($this->extra[$name]);
                }
                $namespace = $alias->getNamespace();
                if (!isset($namespaces[$namespace])) {
                    $namespaces[$namespace] = array();
                }
                $namespaces[$namespace][] = $alias;
            }
        }
        return $namespaces;
    }
    protected function getAliases()
    {
        // For Laravel, use the AliasLoader
        if (class_exists('Illuminate\Foundation\AliasLoader')) {
            return AliasLoader::getInstance()->getAliases();
        }
        $facades = [
          'App' => 'Illuminate\Support\Facades\App',
          'Auth' => 'Illuminate\Support\Facades\Auth',
          'Bus' => 'Illuminate\Support\Facades\Bus',
          'DB' => 'Illuminate\Support\Facades\DB',
          'Cache' => 'Illuminate\Support\Facades\Cache',
          'Cookie' => 'Illuminate\Support\Facades\Cookie',
          'Crypt' => 'Illuminate\Support\Facades\Crypt',
          'Event' => 'Illuminate\Support\Facades\Event',
          'Hash' => 'Illuminate\Support\Facades\Hash',
          'Log' => 'Illuminate\Support\Facades\Log',
          'Mail' => 'Illuminate\Support\Facades\Mail',
          'Queue' => 'Illuminate\Support\Facades\Queue',
          'Request' => 'Illuminate\Support\Facades\Request',
          'Schema' => 'Illuminate\Support\Facades\Schema',
          'Session' => 'Illuminate\Support\Facades\Session',
          'Storage' => 'Illuminate\Support\Facades\Storage',
          //'Validator' => 'Illuminate\Support\Facades\Validator',
        ];
        $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);
        });
    }
    /**
     * Get the driver/connection/store from the managers
     *
     * @param $alias
     * @return array|bool|string
     */
    public function getDriver($alias)
    {
        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;
        }
    }
    /**
     * Write a string as error output.
     *
     * @param  string  $string
     * @return void
     */
    protected function error($string)
    {
        if ($this->output) {
            $this->output->writeln("<error>$string</error>");
        } else {
            echo $string . "\r\n";
        }
    }
 }
@@ -0,0 +1,87 @@
 <?php
 /**
 * Laravel IDE Helper Generator
 *
 * @author    Barry vd. Heuvel <[email protected]>
 * @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\Support\ServiceProvider;
 use Barryvdh\LaravelIdeHelper\Console\MetaCommand;
 use Barryvdh\LaravelIdeHelper\Console\ModelsCommand;
 use Barryvdh\LaravelIdeHelper\Console\GeneratorCommand;
 class IdeHelperServiceProvider extends ServiceProvider
 {
    /**
     * Indicates if loading of the provider is deferred.
     *
     * @var bool
     */
    protected $defer = true;
    /**
     * Bootstrap the application events.
     *
     * @return void
     */
    public function boot()
    {
        $viewPath = __DIR__.'/../resources/views';
        $this->loadViewsFrom($viewPath, 'ide-helper');
        $configPath = __DIR__ . '/../config/ide-helper.php';
        if (function_exists('config_path')) {
            $publishPath = config_path('ide-helper.php');
        } else {
            $publishPath = base_path('config/ide-helper.php');
        }
        $this->publishes([$configPath => $publishPath], 'config');
    }
    /**
     * Register the service provider.
     *
     * @return void
     */
    public function register()
    {
        $configPath = __DIR__ . '/../config/ide-helper.php';
        $this->mergeConfigFrom($configPath, 'ide-helper');
        $this->app['command.ide-helper.generate'] = $this->app->share(
            function ($app) {
                return new GeneratorCommand($app['config'], $app['files'], $app['view']);
            }
        );
        $this->app['command.ide-helper.models'] = $this->app->share(
            function ($app) {
                return new ModelsCommand($app['files']);
            }
        );
        $this->app['command.ide-helper.meta'] = $this->app->share(
            function ($app) {
                return new MetaCommand($app['files'], $app['view']);
            }
        );
        $this->commands('command.ide-helper.generate', 'command.ide-helper.models', 'command.ide-helper.meta');
    }
    /**
     * Get the services provided by the provider.
     *
     * @return array
     */
    public function provides()
    {
        return array('command.ide-helper.generate', 'command.ide-helper.models');
    }
 }
@@ -0,0 +1,314 @@
 <?php
 /**
 * Laravel IDE Helper Generator
 *
 * @author    Barry vd. Heuvel <[email protected]>
 * @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 Barryvdh\Reflection\DocBlock;
 use Barryvdh\Reflection\DocBlock\Context;
 use Barryvdh\Reflection\DocBlock\Tag;
 use Barryvdh\Reflection\DocBlock\Tag\ReturnTag;
 use Barryvdh\Reflection\DocBlock\Tag\ParamTag;
 use Barryvdh\Reflection\DocBlock\Serializer as DocBlockSerializer;
 class Method
 {
    /** @var \Barryvdh\Reflection\DocBlock  */
    protected $phpdoc;
    /** @var \ReflectionMethod  */
    protected $method;
    protected $output = '';
    protected $name;
    protected $namespace;
    protected $params = array();
    protected $params_with_default = array();
    protected $interfaces = array();
    protected $return = null;
    /**
     * @param \ReflectionMethod $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())
    {
        $this->method = $method;
        $this->interfaces = $interfaces;
        $this->name = $methodName ?: $method->name;
        $this->namespace = $method->getDeclaringClass()->getNamespaceName();
        //Create a DocBlock and serializer instance
        $this->phpdoc = new DocBlock($method, new Context($this->namespace));
        //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
        $declaringClass = $method->getDeclaringClass();
        $this->declaringClassName = '\\' . ltrim($declaringClass->name, '\\');
        $this->root = '\\' . ltrim($class->getName(), '\\');
    }
    /**
     * Get the class wherein the function resides
     *
     * @return string
     */
    public function getDeclaringClass()
    {
        return $this->declaringClassName;
    }
    /**
     * Return the class from which this function would be called
     *
     * @return string
     */
    public function getRoot()
    {
        return $this->root;
    }
    /**
     * Get the docblock for this method
     *
     * @param string $prefix
     * @return mixed
     */
    public function getDocComment($prefix = "\t\t")
    {
        $serializer = new DocBlockSerializer(1, $prefix);
        return $serializer->getDocComment($this->phpdoc);
    }
    /**
     * Get the method name
     *
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }
    /**
     * Get the parameters for this method
     *
     * @param bool $implode Wether to implode the array or not
     * @return string
     */
    public function getParams($implode = true)
    {
        return $implode ? implode(', ', $this->params) : $this->params;
    }
    /**
     * Get the parameters for this method including default values
     *
     * @param bool $implode Wether to implode the array or not
     * @return string
     */
    public function getParamsWithDefault($implode = true)
    {
        return $implode ? implode(', ', $this->params_with_default) : $this->params_with_default;
    }
    /**
     * Get the description and get the inherited docs.
     *
     * @param DocBlock $phpdoc
     */
    protected function normalizeDescription(DocBlock $phpdoc)
    {
        //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($this->method);
            $inheritDescription = $inheritdoc->getText();
            $description = str_replace('{@inheritdoc}', $inheritDescription, $description);
            $phpdoc->setText($description);
            $this->normalizeParams($inheritdoc);
            $this->normalizeReturn($inheritdoc);
            //Add the tags that are inherited
            $inheritTags = $inheritdoc->getTags();
            if ($inheritTags) {
                /** @var Tag $tag */
                foreach ($inheritTags as $tag) {
                    $tag->setDocBlock();
                    $phpdoc->appendTag($tag);
                }
            }
        }
    }
    /**
     * Normalize the parameters
     *
     * @param DocBlock $phpdoc
     */
    protected function normalizeParams(DocBlock $phpdoc)
    {
        //Get the return type and adjust them for beter autocomplete
        $paramTags = $phpdoc->getTagsByName('param');
        if ($paramTags) {
            /** @var ParamTag $tag */
            foreach ($paramTags as $tag) {
                // Convert the keywords
                $content = $this->convertKeywords($tag->getContent());
                $tag->setContent($content);
                // Get the expanded type and re-set the content
                $content = $tag->getType() . ' ' . $tag->getVariableName() . ' ' . $tag->getDescription();
                $tag->setContent(trim($content));
            }
        }
    }
    /**
     * Normalize the return tag (make full namespace, replace interfaces)
     *
     * @param DocBlock $phpdoc
     */
    protected function normalizeReturn(DocBlock $phpdoc)
    {
        //Get the return type and adjust them for beter autocomplete
        $returnTags = $phpdoc->getTagsByName('return');
        if ($returnTags) {
            /** @var ReturnTag $tag */
            $tag = reset($returnTags);
            // Get the expanded type
            $returnValue = $tag->getType();
            // Replace the interfaces
            foreach ($this->interfaces as $interface => $real) {
                $returnValue = str_replace($interface, $real, $returnValue);
            }
            // Set the changed content
            $tag->setContent($returnValue . ' ' . $tag->getDescription());
            $this->return = $returnValue;
        } else {
            $this->return = null;
        }
    }
    /**
     * Convert keywwords that are incorrect.
     *
     * @param  string $string
     * @return string
     */
    protected function convertKeywords($string)
    {
        $string = str_replace('\Closure', 'Closure', $string);
        $string = str_replace('Closure', '\Closure', $string);
        $string = str_replace('dynamic', 'mixed', $string);
        return $string;
    }
    /**
     * Should the function return a value?
     *
     * @return bool
     */
    public function shouldReturn()
    {
        if ($this->return !== "void" && $this->method->name !== "__construct") {
            return true;
        }
        return false;
    }
    /**
     * Get the parameters and format them correctly
     *
     * @param  \ReflectionMethod $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->isDefaultValueAvailable() ? $param->getDefaultValue() : null;
                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;
                } elseif (is_resource($default)) {
                    //skip to not fail
                } else {
                    $default = "'" . trim($default) . "'";
                }
                $paramStr .= " = $default";
            }
            $paramsWithDefault[] = $paramStr;
        }
        $this->params = $params;
        $this->params_with_default = $paramsWithDefault;
    }
    /**
     * @param \ReflectionMethod $reflectionMethod
     * @return DocBlock
     */
    protected function getInheritDoc($reflectionMethod)
    {
        $parentClass = $reflectionMethod->getDeclaringClass()->getParentClass();
        //Get either a parent or the interface
        if ($parentClass) {
            $method = $parentClass->getMethod($reflectionMethod->getName());
        } else {
            $method = $reflectionMethod->getPrototype();
        }
        if ($method) {
            $namespace = $method->getDeclaringClass()->getNamespaceName();
            $phpdoc = new DocBlock($method, new Context($namespace));
            if (strpos($phpdoc->getText(), '{@inheritdoc}') !== false) {
                //Not at the end yet, try another parent/interface..
                return $this->getInheritDoc($method);
            } else {
                return $phpdoc;
            }
        }
    }
 }
@@ -1,89 +0,0 @@
 <?php
 return array(
    /*
    |--------------------------------------------------------------------------
    | Filename
    |--------------------------------------------------------------------------
    |
    | The default path to the helper file
    |
    */
    '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
    |--------------------------------------------------------------------------
    |
    | Include helper files. By default not included, but can be toggled with the
    | -- helpers (-H) option. Extra helper files can be included.
    |
    */
    'include_helpers' => false,
    'helper_files' => array(
        base_path().'/vendor/laravel/framework/src/Illuminate/Support/helpers.php',
    ),
    /*
    |--------------------------------------------------------------------------
    | Extra classes
    |--------------------------------------------------------------------------
    |
    | These implementations are not really extended, but called with magic functions
    |
    */
    'extra' => array(
        'Auth'      => array('Illuminate\Auth\Guard'),
        'Cache'     => array('Illuminate\Cache\StoreInterface', 'Illuminate\Cache\Repository'),
        'DB'        => array('Illuminate\Database\Connection'),
        'Eloquent'  => array('Illuminate\Database\Query\Builder'),
        'Queue'     => array('Illuminate\Queue\QueueInterface'),
    ),
    /*
    |--------------------------------------------------------------------------
    | Non-static methods
    |--------------------------------------------------------------------------
    |
    | These functions aren't actually facade calls, so don't make them static
    |
    */
    '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',
    ),
 );
@@ -0,0 +1,58 @@
 <?php
 namespace Barryvdh\LaravelIdeHelper;
 class ExampleTest extends \PHPUnit_Framework_TestCase
 {
    /**
     * Test that we can actually instantiate the class
     */
    public function testCanInstantiate()
    {
        $reflectionClass = new \ReflectionClass(ExampleClass::class);
        $reflectionMethod = $reflectionClass->getMethod('setName');
        $method = new Method($reflectionMethod, 'Example', $reflectionClass);
        $this->assertInstanceOf(Method::class, $method);
    }
    /**
     * Test the output of a class
     */
    public function testOutput()
    {
        $reflectionClass = new \ReflectionClass(ExampleClass::class);
        $reflectionMethod = $reflectionClass->getMethod('setName');
        $method = new Method($reflectionMethod, 'Example', $reflectionClass);
        $output = '/**
 * 
 *
 * @param string $last
 * @param string $first
 * @static 
 */';
        $this->assertEquals($output, $method->getDocComment(''));
        $this->assertEquals('setName', $method->getName());
        $this->assertEquals('\\'.ExampleClass::class, $method->getDeclaringClass());
        $this->assertEquals('$last, $first', $method->getParams(true));
        $this->assertEquals(['$last', '$first'], $method->getParams(false));
        $this->assertEquals('$last, $first = \'Barry\'', $method->getParamsWithDefault(true));
        $this->assertEquals(['$last', '$first = \'Barry\''], $method->getParamsWithDefault(false));
        $this->assertEquals(true, $method->shouldReturn());
    }
 }
 class ExampleClass
 {
    /**
     * @param string $last
     * @param string $first
     */
    public function setName($last, $first = 'Barry')
    {
        return;
    }
 }