Compare 248a052 ... +21 ... f98914a

     * @param array|Route $routeOrAction

    public static function getRouteClassAndMethodNames($routeOrAction)

        $action = $routeOrAction instanceof Route ? $routeOrAction->getAction() : $routeOrAction;

<?php

namespace Mpociot\ApiDoc\Strategies\Responses;

use Illuminate\Routing\Route;

use Mpociot\Reflection\DocBlock;

use Mpociot\Reflection\DocBlock\Tag;

use Mpociot\ApiDoc\Strategies\Strategy;

use Mpociot\ApiDoc\Tools\RouteDocBlocker;

/**

 * Get a response from the docblock ( @response ).

 */

class UseResponseTag extends Strategy

{

    /**

     * @param Route $route

     * @param \ReflectionClass $controller

     * @param \ReflectionMethod $method

     * @param array $routeRules

     * @param array $context

     *

     * @throws \Exception

     *

     * @return array|null

     */

    public function __invoke(Route $route, \ReflectionClass $controller, \ReflectionMethod $method, array $routeRules, array $context = [])

    {

        $docBlocks = RouteDocBlocker::getDocBlocksFromRoute($route);

        /** @var DocBlock $methodDocBlock */

        $methodDocBlock = $docBlocks['method'];

        return $this->getDocBlockResponses($methodDocBlock->getTags());

    }

    /**

     * Get the response from the docblock if available.

     *

     * @param array $tags

     *

     * @return array|null

     */

    protected function getDocBlockResponses(array $tags)

    {

        $responseTags = array_values(

            array_filter($tags, function ($tag) {

                return $tag instanceof Tag && strtolower($tag->getName()) === 'response';

            })

        );

        if (empty($responseTags)) {

            return null;

        }

        $responses = array_map(function (Tag $responseTag) {

            preg_match('/^(\d{3})?\s?([\s\S]*)$/', $responseTag->getContent(), $result);

            $status = $result[1] ?: 200;

            $content = $result[2] ?: '{}';

            return [$content, (int) $status];

        }, $responseTags);

        // Convert responses to [200 => 'response', 401 => 'response']

        return collect($responses)->pluck('0', '1')->toArray();

    }

}

<?php

namespace Mpociot\ApiDoc\Tools\Traits;

use Mpociot\Reflection\DocBlock\Tag;

trait DocBlockParamHelpers

{

    use ParamHelpers;

    /**

     * Allows users to specify that we shouldn't generate an example for the parameter

     * by writing 'No-example'.

     *

     * @param Tag $tag

     *

     * @return bool Whether no example should be generated

     */

    protected function shouldExcludeExample(Tag $tag)

    {

        return strpos($tag->getContent(), ' No-example') !== false;

    }

    /**

     * Allows users to specify an example for the parameter by writing 'Example: the-example',

     * to be used in example requests and response calls.

     *

     * @param string $description

     * @param string $type The type of the parameter. Used to cast the example provided, if any.

     *

     * @return array The description and included example.

     */

    protected function parseParamDescription(string $description, string $type)

    {

        $example = null;

        if (preg_match('/(.*)\s+Example:\s*(.*)\s*/', $description, $content)) {

            $description = $content[1];

            // examples are parsed as strings by default, we need to cast them properly

            $example = $this->castToType($content[2], $type);

        }

        return [$description, $example];

    }

}

        $action = Utils::getRouteClassAndMethodNames($route->getAction());

        list($class, $method) = Utils::getRouteClassAndMethodNames($action);

use Faker\Factory;

    protected function generateDummyValue(string $type)

    {

        $faker = Factory::create();

        if ($this->config->get('faker_seed')) {

            $faker->seed($this->config->get('faker_seed'));

        }

        $fakeFactories = [

            'integer' => function () use ($faker) {

                return $faker->numberBetween(1, 20);

            },

            'number' => function () use ($faker) {

                return $faker->randomFloat();

            },

            'float' => function () use ($faker) {

                return $faker->randomFloat();

            },

            'boolean' => function () use ($faker) {

                return $faker->boolean();

            },

            'string' => function () use ($faker) {

                return $faker->word;

            },

            'array' => function () {

                return [];

            },

            'object' => function () {

                return new \stdClass;

            },

        ];

        $fakeFactory = $fakeFactories[$type] ?? $fakeFactories['string'];

        return $fakeFactory();

    }

     * Cast a value from a string to a specified type.

     * @param string $value

     * @param string $type

     * @return mixed

    protected function castToType(string $value, string $type)

        $casts = [

            'integer' => 'intval',

            'number' => 'floatval',

            'float' => 'floatval',

            'boolean' => 'boolval',

        ];

        // First, we handle booleans. We can't use a regular cast,

        //because PHP considers string 'false' as true.

        if ($value == 'false' && $type == 'boolean') {

            return false;

        }

        if (isset($casts[$type])) {

            return $casts[$type]($value);

        return $value;

     * Normalizes the stated "type" of a parameter (eg "int", "integer", "double")

     * to a number of standard types (integer, boolean, float).

     * @param string $type

     * @return mixed|string

    protected function normalizeParameterType(string $type)

        $typeMap = [

            'int' => 'integer',

            'bool' => 'boolean',

            'double' => 'float',

        ];

        return $type ? ($typeMap[$type] ?? $type) : 'string';