) will be sorted instead
23 | * of the itself.
24 | */
25 | jQuery.fn.sortElements = (function(){
26 |
27 | var sort = [].sort;
28 |
29 | return function(comparator, getSortable) {
30 |
31 | getSortable = getSortable || function(){return this;};
32 |
33 | var placements = this.map(function(){
34 |
35 | var sortElement = getSortable.call(this),
36 | parentNode = sortElement.parentNode,
37 |
38 | // Since the element itself will change position, we have
39 | // to have some way of storing it's original position in
40 | // the DOM. The easiest way is to have a 'flag' node:
41 | nextSibling = parentNode.insertBefore(
42 | document.createTextNode(''),
43 | sortElement.nextSibling
44 | );
45 |
46 | return function() {
47 |
48 | if (parentNode === this) {
49 | throw new Error(
50 | "You can't sort elements if any one is a descendant of another."
51 | );
52 | }
53 |
54 | // Insert before flag:
55 | parentNode.insertBefore(this, nextSibling);
56 | // Remove flag:
57 | parentNode.removeChild(nextSibling);
58 |
59 | };
60 |
61 | });
62 |
63 | return sort.call(this, comparator).each(function(i){
64 | placements[i].call(getSortable.call(this));
65 | });
66 |
67 | };
68 |
69 | })();
--------------------------------------------------------------------------------
/templates/pages/classlike.twig:
--------------------------------------------------------------------------------
1 | {% extends 'page.twig' %}
2 |
3 | {% block title type|capitalize ~ ' ' ~ ref.name %}
4 |
5 | {% block content %}
6 |
7 |
8 | {{ type|capitalize }}
9 | {% if ref.doc.tags.deprecated is defined %}
10 | {{ ref.name }}
11 | {% else %}
12 | {{ ref.name }}
13 | {% endif %}
14 | {% if ref.source.inProject %}
15 |
18 |
19 |
20 | {{ ref.doc.summary|markdown_to_html }}
21 | {{ ref.doc.description|markdown_to_html }}
22 |
23 |
24 | {#{{ macros.showInheritanceTree(ref.inheritanceTree) }}#}
25 |
26 |
27 | {% if ref.final ?? false %}
28 |
Final
29 | {% endif %}
30 | {% if ref.abstract ?? false %}
31 |
Abstract
32 | {% endif %}
33 |
34 |
Namespace: {{ ref.context.namespace }}
35 |
36 | {% if ref.doc.tags.deprecated is defined %}
37 |
Deprecated: {{ ref.doc.tags.deprecated }}
38 | {% endif %}
39 |
40 | {% if ref.doc.tags.experimental is defined %}
41 |
Experimental: Expect API changes in minor releases.
42 | {% endif %}
43 |
44 | {% for tag in ref.doc.tags.see|default([]) %}
45 |
See: {{ tag.value }}
46 | {% endfor %}
47 |
48 | {% for tag in ref.doc.tags.link|default([]) %}
49 |
Link: {{ tag.value }}
50 | {% endfor %}
51 |
52 |
53 | {% if ref.constants %}
54 | {{ include('pages/parts/constant-detail.twig', {constants: ref.constants}) }}
55 | {% endif %}
56 |
57 | {% if ref.properties %}
58 | {{ include('pages/parts/property-summary.twig', {properties: ref.properties}) }}
59 | {% endif %}
60 |
61 | {% if ref.methods %}
62 | {{ include('pages/parts/function-summary.twig', {functions: ref.methods}) }}
63 |
64 | {{ include('pages/parts/function-detail.twig', {functions: ref.methods}) }}
65 | {% endif %}
66 |
67 | {% if ref.properties %}
68 | {{ include('pages/parts/property-detail.twig', {properties: ref.properties}) }}
69 | {% endif %}
70 |
$imports Imports
67 | * @param string $name Element name
68 | * @return string
69 | */
70 | protected function resolve(array $imports, string $name): string
71 | {
72 | if (!$name) {
73 | return $name;
74 | }
75 |
76 | if ($name[0] === '\\') {
77 | return substr($name, 1);
78 | }
79 |
80 | $first = strchr($name, '\\', true);
81 | if ($first === false) {
82 | $first = $name;
83 | $append = '';
84 | } else {
85 | $append = substr($name, strlen($first));
86 | }
87 |
88 | if (isset($imports[$first])) {
89 | return $imports[$first] . $append;
90 | }
91 |
92 | return $this->namespace ? ($this->namespace . '\\' . $name) : $name;
93 | }
94 | }
95 |
--------------------------------------------------------------------------------
/src/Loader.php:
--------------------------------------------------------------------------------
1 | projectPath = $projectPath;
44 | $this->parser = (new ParserFactory())->create(ParserFactory::PREFER_PHP7);
45 | }
46 |
47 | /**
48 | * @param string $path Directory path
49 | * @param bool $inProject Whether directory is within project
50 | * @return array
51 | */
52 | public function loadDirectory(string $path, bool $inProject): array
53 | {
54 | $nodes = [];
55 | $directoryIterator = new RecursiveDirectoryIterator(
56 | $path,
57 | FilesystemIterator::SKIP_DOTS | FilesystemIterator::CURRENT_AS_PATHNAME
58 | );
59 | foreach (new RecursiveIteratorIterator($directoryIterator) as $filePath) {
60 | if (preg_match('/\.php$/', $filePath)) {
61 | $nodes = array_merge($nodes, $this->loadFile($filePath, $inProject));
62 | }
63 | }
64 |
65 | return $nodes;
66 | }
67 |
68 | /**
69 | * @param string $path File path
70 | * @param bool $inProject Whether file is within project
71 | * @return array
72 | */
73 | public function loadFile(string $path, bool $inProject): array
74 | {
75 | $stmts = $this->parser->parse(file_get_contents($path));
76 |
77 | $traverser = new NodeTraverser();
78 | $visitor = new FileVisitor(new Factory(), substr($path, strlen($this->projectPath) + 1), $inProject);
79 | $traverser->addVisitor($visitor);
80 | $traverser->traverse($stmts);
81 |
82 | $nodes = $visitor->getNodes();
83 | foreach ($nodes as $node) {
84 | if ($node instanceof ReflectedClassLike) {
85 | $this->cache[$node->qualifiedName()] = $node;
86 | }
87 | }
88 |
89 | return $nodes;
90 | }
91 | }
92 |
--------------------------------------------------------------------------------
/static/assets/resources/css/prism.css:
--------------------------------------------------------------------------------
1 | /* PrismJS 1.22.0
2 | https://prismjs.com/download.html#themes=prism&languages=markup+css+clike+javascript+javadoclike+markup-templating+php+phpdoc+php-extras */
3 | /**
4 | * prism.js default theme for JavaScript, CSS and HTML
5 | * Based on dabblet (http://dabblet.com)
6 | * @author Lea Verou
7 | */
8 |
9 | code[class*="language-"],
10 | pre[class*="language-"] {
11 | color: black;
12 | background: none;
13 | text-shadow: 0 1px white;
14 | font-family: Consolas, Monaco, 'Andale Mono', 'Ubuntu Mono', monospace;
15 | text-align: left;
16 | white-space: pre;
17 | word-spacing: normal;
18 | word-break: normal;
19 | word-wrap: normal;
20 | line-height: 1.5;
21 |
22 | -moz-tab-size: 4;
23 | -o-tab-size: 4;
24 | tab-size: 4;
25 |
26 | -webkit-hyphens: none;
27 | -moz-hyphens: none;
28 | -ms-hyphens: none;
29 | hyphens: none;
30 | }
31 |
32 | pre[class*="language-"]::-moz-selection, pre[class*="language-"] ::-moz-selection,
33 | code[class*="language-"]::-moz-selection, code[class*="language-"] ::-moz-selection {
34 | text-shadow: none;
35 | background: #b3d4fc;
36 | }
37 |
38 | pre[class*="language-"]::selection, pre[class*="language-"] ::selection,
39 | code[class*="language-"]::selection, code[class*="language-"] ::selection {
40 | text-shadow: none;
41 | background: #b3d4fc;
42 | }
43 |
44 | @media print {
45 | code[class*="language-"],
46 | pre[class*="language-"] {
47 | text-shadow: none;
48 | }
49 | }
50 |
51 | /* Code blocks */
52 | pre[class*="language-"] {
53 | padding: 1em;
54 | margin: .5em 0;
55 | overflow: auto;
56 | }
57 |
58 | :not(pre) > code[class*="language-"],
59 | pre[class*="language-"] {
60 | background: #f5f2f0;
61 | }
62 |
63 | /* Inline code */
64 | :not(pre) > code[class*="language-"] {
65 | padding: .1em;
66 | border-radius: .3em;
67 | white-space: normal;
68 | }
69 |
70 | .token.comment,
71 | .token.prolog,
72 | .token.doctype,
73 | .token.cdata {
74 | color: slategray;
75 | }
76 |
77 | .token.punctuation {
78 | color: #999;
79 | }
80 |
81 | .token.namespace {
82 | opacity: .7;
83 | }
84 |
85 | .token.property,
86 | .token.tag,
87 | .token.boolean,
88 | .token.number,
89 | .token.constant,
90 | .token.symbol,
91 | .token.deleted {
92 | color: #905;
93 | }
94 |
95 | .token.selector,
96 | .token.attr-name,
97 | .token.string,
98 | .token.char,
99 | .token.builtin,
100 | .token.inserted {
101 | color: #690;
102 | }
103 |
104 | .token.operator,
105 | .token.entity,
106 | .token.url,
107 | .language-css .token.string,
108 | .style .token.string {
109 | color: #9a6e3a;
110 | /* This background color was intended by the author of this theme. */
111 | background: hsla(0, 0%, 100%, .5);
112 | }
113 |
114 | .token.atrule,
115 | .token.attr-value,
116 | .token.keyword {
117 | color: #07a;
118 | }
119 |
120 | .token.function,
121 | .token.class-name {
122 | color: #DD4A68;
123 | }
124 |
125 | .token.regex,
126 | .token.important,
127 | .token.variable {
128 | color: #e90;
129 | }
130 |
131 | .token.important,
132 | .token.bold {
133 | font-weight: bold;
134 | }
135 | .token.italic {
136 | font-style: italic;
137 | }
138 |
139 | .token.entity {
140 | cursor: help;
141 | }
142 |
143 |
--------------------------------------------------------------------------------
/templates/footer.twig:
--------------------------------------------------------------------------------
1 |
17 |
18 |
78 |
--------------------------------------------------------------------------------
/src/ProjectNamespace.php:
--------------------------------------------------------------------------------
1 |
36 | */
37 | public array $children = [];
38 |
39 | /**
40 | * @var array
41 | */
42 | public array $defines = [];
43 |
44 | /**
45 | * @var array
46 | */
47 | public array $constants = [];
48 |
49 | /**
50 | * @var array
51 | */
52 | public array $functions = [];
53 |
54 | /**
55 | * @var array
56 | */
57 | public array $interfaces = [];
58 |
59 | /**
60 | * @var array
61 | */
62 | public array $classes = [];
63 |
64 | /**
65 | * @var array
66 | */
67 | public array $traits = [];
68 |
69 | /**
70 | * @param string $name Display name
71 | * @param string|null $qualifiedName Qualified name
72 | */
73 | public function __construct(string $name, ?string $qualifiedName)
74 | {
75 | $this->name = $name;
76 | $this->qualifiedName = $qualifiedName;
77 | }
78 |
79 | /**
80 | * @return bool
81 | */
82 | public function isEmpty(): bool
83 | {
84 | return empty($this->children) &&
85 | empty($this->constants) &&
86 | empty($this->functions) &&
87 | empty($this->interfaces) &&
88 | empty($this->classes) &&
89 | empty($this->traits);
90 | }
91 |
92 | /**
93 | * @param \Cake\ApiDocs\Reflection\ReflectedNode $ref Ref to add
94 | * @return void
95 | */
96 | public function addNode(ReflectedNode $ref): void
97 | {
98 | if ($ref instanceof ReflectedDefine) {
99 | $this->constants[$ref->name] = $ref;
100 | ksort($this->constants);
101 | } elseif ($ref instanceof ReflectedFunction) {
102 | $this->functions[$ref->name] = $ref;
103 | ksort($this->functions);
104 | } elseif ($ref instanceof ReflectedInterface) {
105 | $this->interfaces[$ref->name] = $ref;
106 | ksort($this->interfaces);
107 | } elseif ($ref instanceof ReflectedClass) {
108 | $this->classes[$ref->name] = $ref;
109 | ksort($this->classes);
110 | } elseif ($ref instanceof ReflectedTrait) {
111 | $this->traits[$ref->name] = $ref;
112 | ksort($this->traits);
113 | } else {
114 | throw new InvalidArgumentException(sprintf('Cannot add node of type %s.', get_class($ref)));
115 | }
116 | }
117 | }
118 |
--------------------------------------------------------------------------------
/src/Twig/Extension/ReflectionExtension.php:
--------------------------------------------------------------------------------
1 | project = $project;
40 | }
41 |
42 | /**
43 | * @inheritDoc
44 | */
45 | public function getFilters()
46 | {
47 | return [
48 | new TwigFilter('classlike_to_url', function (string $name, string $type) {
49 | return sprintf('%s-%s.html', $type, preg_replace('[\\\\]', '.', $name));
50 | }),
51 | new TwigFilter('namespace_to_url', function (?string $name) {
52 | return sprintf('namespace-%s.html', preg_replace('[\\\\]', '.', $name ?: 'Global'));
53 | }),
54 | new TwigFilter('type', function (?TypeNode $type) {
55 | // Remove parenthesis added by phpstan around union and intersection types
56 | // Remove space around union and intersection delimiter
57 | // Remove leading \ in front of types
58 | return preg_replace(
59 | [
60 | '/ ([|&]) /',
61 | '/<\(/',
62 | '/\)>/',
63 | '/\), /',
64 | '/, \(/',
65 | '/^\((.*)\)$/',
66 | '/(?<=[(<|&])\\\\/',
67 | '/^\\\\/',
68 | ],
69 | ['${1}', '<', '>', ', ', ', ', '${1}', '', ''],
70 | (string)$type
71 | );
72 | }),
73 | new TwigFilter('node_to_repo_url', function (ReflectedNode $node) {
74 | preg_match('/^(?:origin\/)?(.*)$/', $this->project->getConfig('tag'), $matches);
75 |
76 | return sprintf(
77 | '%s/blob/%s/%s#L%d',
78 | $this->project->getConfig('repo'),
79 | $matches[1],
80 | $node->source->path,
81 | $node->source->startLine
82 | );
83 | }),
84 | ];
85 | }
86 |
87 | /**
88 | * @inheritDoc
89 | */
90 | public function getTests()
91 | {
92 | return [
93 | ];
94 | }
95 |
96 | /**
97 | * @inheritDoc
98 | */
99 | public function getFunctions()
100 | {
101 | return [
102 | new TwigFunction('inNamespace', function (?string $name, ?string $namespace) {
103 | if ($name === null && $namespace !== null) {
104 | return false;
105 | }
106 |
107 | if ($name === null && $namespace == null) {
108 | return true;
109 | }
110 |
111 | return str_starts_with($namespace ?? '', $name);
112 | }),
113 | ];
114 | }
115 | }
116 |
--------------------------------------------------------------------------------
/src/Command/GenerateCommand.php:
--------------------------------------------------------------------------------
1 | addArgument('project-path', [
42 | 'required' => true,
43 | 'help' => 'The project root path. Source directories are relative to this.',
44 | ]);
45 |
46 | $parser->addOption('output-dir', [
47 | 'required' => true,
48 | 'help' => 'The render output directory.',
49 | ]);
50 |
51 | $parser->addOption('config', [
52 | 'required' => true,
53 | 'help' => 'The config name to use, for example: cakephp4.',
54 | ]);
55 |
56 | $parser->addOption('version', [
57 | 'required' => true,
58 | 'help' => 'The project version (example: 4.0)',
59 | ]);
60 |
61 | $parser->addOption('tag', [
62 | 'required' => true,
63 | 'help' => 'The github tag or branch name',
64 | ]);
65 |
66 | return $parser;
67 | }
68 |
69 | /**
70 | * @inheritDoc
71 | */
72 | public function execute(Arguments $args, ConsoleIo $io): ?int
73 | {
74 | Configure::config('default', new PhpConfig());
75 | Configure::load($args->getOption('config'), 'default', false);
76 |
77 | Configure::write('Project.version', $args->getOption('version'));
78 | Configure::write('Project.tag', $args->getOption('tag'));
79 |
80 | $project = new Project($args->getArgumentAt(0), Configure::read('Project'));
81 |
82 | $twig = $this->createTwig(Configure::read('Twig.templateDir'), $project);
83 | $twig->addGlobal('version', Configure::read('Project.version'));
84 | foreach (Configure::read('Twig.globals') as $name => $value) {
85 | $twig->addGlobal($name, $value);
86 | }
87 |
88 | $generator = new Generator($twig, $args->getOption('output-dir'));
89 | $generator->generate($project);
90 |
91 | return static::CODE_SUCCESS;
92 | }
93 |
94 | /**
95 | * @param string $templateDir Twig template dirctory
96 | * @param \Cake\ApiDocs\Project $project Api Project
97 | * @return \Twig\Environment
98 | */
99 | protected function createTwig(string $templateDir, Project $project): Environment
100 | {
101 | $twig = new Environment(
102 | new FilesystemLoader($templateDir),
103 | ['strict_variables' => true]
104 | );
105 |
106 | $twig->addRuntimeLoader(new TwigRuntimeLoader());
107 | $twig->addExtension(new MarkdownExtension());
108 | $twig->addExtension(new ReflectionExtension($project));
109 |
110 | return $twig;
111 | }
112 | }
113 |
--------------------------------------------------------------------------------
/src/Reflection/DocBlock.php:
--------------------------------------------------------------------------------
1 | children as $childNode) {
40 | if (!$childNode instanceof PhpDocTextNode) {
41 | break;
42 | }
43 |
44 | if (!$this->summary) {
45 | $this->summary = $childNode->text;
46 | } else {
47 | if ($this->description) {
48 | $this->description .= "\n" . $childNode->text;
49 | } else {
50 | $this->description = $childNode->text;
51 | }
52 | }
53 | }
54 |
55 | $tags = $node->getTagsByName('@template');
56 | array_walk($tags, fn($tag) => $this->tags['template'][] = $tag->value);
57 |
58 | $tags = $node->getTagsByName('@var');
59 | if ($tags) {
60 | $this->tags['var'] = current($tags)->value;
61 | }
62 |
63 | $tags = $node->getTagsByName('@param');
64 | foreach ($tags as $tag) {
65 | if ($tag->value instanceof InvalidTagValueNode) {
66 | continue;
67 | }
68 | $this->tags['param'][$tag->value->parameterName] = $tag->value;
69 | }
70 |
71 | $tags = $node->getTagsByName('@return');
72 | if ($tags) {
73 | $this->tags['return'] = current($tags)->value;
74 | }
75 |
76 | foreach (['@property', '@property-read', '@property-write'] as $tagName) {
77 | $tags = $node->getTagsByName($tagName);
78 | foreach ($tags as $tag) {
79 | if ($tag->value instanceof InvalidTagValueNode) {
80 | continue;
81 | }
82 | $this->tags[$tagName][$tag->value->propertyName] = $tag->value;
83 | }
84 | }
85 |
86 | $tags = $node->getTagsByName('@method');
87 | foreach ($tags as $tag) {
88 | if ($tag->value instanceof InvalidTagValueNode) {
89 | continue;
90 | }
91 | $this->tags['@method'][$tag->value->methodName] = $tag->value;
92 | }
93 |
94 | $tags = $node->getTagsByName('@throws');
95 | array_walk($tags, fn($tag) => $this->tags['throws'][] = $tag->value);
96 |
97 | $tags = $node->getTagsByName('@see');
98 | array_walk($tags, fn($tag) => $this->tags['see'][] = $tag->value);
99 |
100 | $tags = $node->getTagsByName('@link');
101 | array_walk($tags, fn($tag) => $this->tags['link'][] = $tag->value);
102 |
103 | $tags = $node->getTagsByName('@deprecated');
104 | if ($tags) {
105 | $this->tags['deprecated'] = current($tags)->value;
106 | }
107 |
108 | $tags = $node->getTagsByName('@experimental');
109 | if ($tags) {
110 | $this->tags['experimental'] = current($tags)->value;
111 | }
112 |
113 | $tags = $node->getTagsByName('@internal');
114 | if ($tags) {
115 | $this->tags['internal'] = current($tags)->value;
116 | }
117 | }
118 | }
119 |
--------------------------------------------------------------------------------
/templates/page.twig:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
12 |
13 | {% block title 'API' %} | {{ project ~ ' ' ~ version }}
17 |
18 |
58 | {{ include('header.twig') }}
59 |
60 |
61 |
62 |
63 |
87 |
88 |
89 |
90 | {% block content %}{% endblock %}
91 |
92 |
93 |
94 |
2 |
{{ title|default('Method') }} Detail
3 | {% for function in functions %}
4 |
5 |
6 |
7 | {{ function.name }}()
8 | ¶
9 | {% if function.source.inProject %}
10 | abstract
15 | {% endif %}
16 |
17 | {% if function.visibility is defined %}
18 | {{ function.visibility }}
19 | {% endif %}
20 | {% if function.static %}
21 | static
22 | {% endif %}
23 | {% if function.annotation|default(null) %}
24 | {{ function.annotation }}
25 | {% endif %}
26 | {% if function.doc.tags.depecated is defined %}
27 | deprecated
28 | {% endif %}
29 |
30 |
31 |
32 | {{- function.name }}(
33 | {%- for param in function.params %}
34 | {{- param.type|type|default('mixed') }} {% if param.variadic %}...{% endif %}${{ param.name }}{{ param.default is not null ? ' = ' ~ param.default : '' }}{{ loop.last?'':', ' }}
35 | {%- endfor -%}
36 | ){{ function.returnType ? ': ' ~ function.returnType|type : '' -}}
37 |
38 |
39 |
40 | {{ function.doc.summary|markdown_to_html }}
41 | {{ function.doc.description|markdown_to_html }}
42 |
43 | {% if function.doc.tags.template is defined %}
44 |
Templates
45 |
46 | {% for tag in function.doc.tags.template %}
47 |
48 | {{ tag.name }}
49 | {% if tag.bound is not null %} of {{tag.bound}}{% endif %}
50 | {% if tag.default is not null %} = {{tag.default}}{% endif %}
51 |
55 | {% endif %}
56 |
57 | {% if function.params %}
58 |
Parameters
59 |
60 |
61 | {% for param in function.params %}
62 |
63 | {{ param.type|type }}
64 | {% if param.variadic %}...{% endif %}${{ param.name }}
65 | {% if param.default is not null %}
66 | optional
67 | {% endif %}
68 |
69 | {{ (param.description ?? '')|markdown_to_html }}
70 | {% endfor %}
71 |
72 |
73 | {% endif %}
74 |
75 | {% if function.returnType %}
76 |
Returns
77 |
78 | {{ function.returnType|type }}
83 | {% endif %}
84 |
85 | {% if function.doc.tags.throws is defined %}
86 |
Throws
87 |
88 | {% for tag in function.doc.tags.throws %}
89 | {{ tag.type|type }}
93 | {% endif %}
94 |
95 | {% if function.doc.tags.see is defined %}
96 |
See Also
97 |
98 | {% for tag in function.doc.tags.see %}
99 | {{ tag.value }}{{ loop.last ? '': '
102 | {% endif %}
103 |
104 | {% if function.doc.tags.link is defined %}
105 |
Links
106 |
107 | {% for tag in function.doc.tags.link %}
108 | {{ tag.value }}
111 | {% endif %}
112 |
113 |
114 | {% endfor %}
115 |
189 | */
190 | protected function normalizeUse(UseUse $use, ?string $prefix = null): array
191 | {
192 | $name = (string)$use->name;
193 | if ($prefix) {
194 | $name = $prefix . '\\' . $name;
195 | }
196 |
197 | $alias = $use->alias;
198 | if (!$alias) {
199 | $last = strrpos($name, '\\', -1);
200 | if ($last !== false) {
201 | $alias = substr($name, strrpos($name, '\\', -1) + 1);
202 | } else {
203 | $alias = $name;
204 | }
205 | }
206 |
207 | return [(string)$alias => $name];
208 | }
209 |
210 | /**
211 | * @param string $name Node name
212 | * @return string
213 | */
214 | protected function addNamespace(string $name): string
215 | {
216 | if ($this->context->namespace) {
217 | return $this->context->namespace . '\\' . $name;
218 | }
219 |
220 | return $name;
221 | }
222 | }
223 |
--------------------------------------------------------------------------------
/templates/header.twig:
--------------------------------------------------------------------------------
1 | {# Red Mega Menu #}
2 |
3 |
4 |
5 |
10 |
11 |
12 |
13 |
44 |
45 |
46 |
47 |
51 |
52 |
57 |
58 |
59 |
60 |
63 |
64 |
65 |
70 |
71 |
72 |
73 |
77 |
78 |
79 |
88 |
89 |
90 |
91 | {#
92 |
93 |
94 | Overview
95 |
96 | #}
97 |
98 | {#
99 |
100 |
101 | Tree
102 |
103 | #}
104 |
105 | {#
106 |
107 |
108 | Deprecated
109 |
110 | #}
111 |
112 | {# Project picker #}
113 |
114 | Project:
115 |
130 |
131 |
132 | {# Version picker #}
133 |
134 | Version:
135 |
147 |
148 |
149 |
150 |
151 |
163 |
164 |
166 |
167 |
168 | {# Responsive grey bar navigation. This is outside of header so it scrolls with the page. #}
169 |
170 |
171 |
172 |
173 | Navigation
175 |
176 |
177 | Class Navigation
179 |
180 |
182 |
183 | {# modal used in mobile responsive views #}
184 |
185 |
186 |
187 |
193 |
{# body is injected via js #}
194 |
195 |
196 |
' + data[1].replace(/^(.+\\)(.+)$/, '$1 $2') + ' ';
274 | },
275 | formatMatch: function(data) {
276 | return data[1];
277 | },
278 | formatResult: function(data) {
279 | return data[1];
280 | },
281 | show: function(list) {
282 | var listWidth = list.width();
283 | var items = $('li span', list);
284 | if (isMobileDevice) {
285 | // Make the results full width
286 | list.width('100%').css('left', 0);
287 | } else {
288 | var listLeft = parseInt(list.css('left'), 10);
289 | var maxWidth = Math.max.apply(null, items.map(function() {
290 | return $(this).width();
291 | }));
292 | // Make the results wider, and shift left to accomodate new width.
293 | list
294 | .width(Math.max(maxWidth, $search.innerWidth()))
295 | .css('left', listLeft - Math.max(0, maxWidth - listWidth));
296 | }
297 | }
298 | }).result(function(event, data) {
299 | autocompleteFound = true;
300 | var location = window.location.href.split('/');
301 | location.pop();
302 | var parts = data[1].split(/::|$/);
303 | var file = autocompleteFiles[data[0]] + '-' + parts[0].replace(/\\/g, '.') + '.html';
304 | if (parts[1]) {
305 | file += '#' + parts[1];
306 | }
307 | location.push(file);
308 | window.location = location.join('/');
309 |
310 | // Workaround for Opera bug
311 | $(this).closest('form').attr('action', location.join('/'));
312 | }).closest('form')
313 | .submit(function() {
314 | var query = $search.val();
315 | if ('' === query) {
316 | return false;
317 | }
318 |
319 | var label = $('#search input[name=more]').val();
320 | if (!autocompleteFound && label && -1 === query.indexOf('more:')) {
321 | $search.val(query + ' more:' + label);
322 | }
323 |
324 | return !autocompleteFound && '' !== $('#search input[name=cx]').val();
325 | });
326 |
327 | // Open details
328 | if (false/*elementDetailsCollapsed*/) {
329 | $('tr', $content).filter(':has(.detailed)')
330 | .click(function() {
331 | var $this = $(this);
332 | $('.short', $this).hide();
333 | $('.detailed', $this).show();
334 | });
335 | }
336 |
337 | // Select selected lines
338 | var matches = window.location.hash.substr(1).match(/^\d+(?:-\d+)?(?:,\d+(?:-\d+)?)*$/);
339 | if (null !== matches) {
340 | var lists = matches[0].split(',');
341 | for (var i = 0; i < lists.length; i++) {
342 | var lines = lists[i].split('-');
343 | lines[1] = lines[1] || lines[0];
344 | for (var j = lines[0]; j <= lines[1]; j++) {
345 | $('#' + j).addClass('selected');
346 | }
347 | }
348 |
349 | var scrollToLineNumber = function() {
350 | console.log('plop');
351 | var offset = 0;
352 | var $header = $('header');
353 | if ($header.length > 0) {
354 | offset = $header.height() + parseInt($header.css('top'));
355 | }
356 |
357 | var $firstLine = $('#' + parseInt(matches[0]));
358 | if ($firstLine.length > 0) {
359 | $(document).scrollTop($firstLine.offset().top - offset);
360 | }
361 | };
362 | scrollToLineNumber();
363 | setTimeout(scrollToLineNumber, 400);
364 | }
365 |
366 | // Save selected lines
367 | var lastLine;
368 | $('a.l').click(function(event) {
369 | event.preventDefault();
370 |
371 | var $selectedLine = $(this).parent();
372 | var selectedLine = parseInt($selectedLine.attr('id'));
373 |
374 | if (event.shiftKey) {
375 | if (lastLine) {
376 | for (var i = Math.min(selectedLine, lastLine); i <= Math.max(selectedLine, lastLine); i++) {
377 | $('#' + i).addClass('selected');
378 | }
379 | } else {
380 | $selectedLine.addClass('selected');
381 | }
382 | } else if (event.ctrlKey) {
383 | $selectedLine.toggleClass('selected');
384 | } else {
385 | var $selected = $('.l.selected')
386 | .not($selectedLine)
387 | .removeClass('selected');
388 | if ($selected.length > 0) {
389 | $selectedLine.addClass('selected');
390 | } else {
391 | $selectedLine.toggleClass('selected');
392 | }
393 | }
394 |
395 | lastLine = $selectedLine.hasClass('selected') ? selectedLine : null;
396 |
397 | // Update hash
398 | var lines = $('.l.selected')
399 | .map(function() {
400 | return parseInt($(this).attr('id'));
401 | })
402 | .get()
403 | .sort(function(a, b) {
404 | return a - b;
405 | });
406 |
407 | var hash = [];
408 | var list = [];
409 | for (var j = 0; j < lines.length; j++) {
410 | if (0 === j && j + 1 === lines.length) {
411 | hash.push(lines[j]);
412 | } else if (0 === j) {
413 | list[0] = lines[j];
414 | } else if (lines[j - 1] + 1 !== lines[j] && j + 1 === lines.length) {
415 | hash.push(list.join('-'));
416 | hash.push(lines[j]);
417 | } else if (lines[j - 1] + 1 !== lines[j]) {
418 | hash.push(list.join('-'));
419 | list = [lines[j]];
420 | } else if (j + 1 === lines.length) {
421 | list[1] = lines[j];
422 | hash.push(list.join('-'));
423 | } else {
424 | list[1] = lines[j];
425 | }
426 | }
427 |
428 | window.location.hash = hash.join(',');
429 | });
430 | });
431 |
--------------------------------------------------------------------------------
/src/Factory.php:
--------------------------------------------------------------------------------
1 | getDocComment()?->getText());
63 |
64 | $const = new ReflectedDefine($node->name->name, $doc, $context, $source);
65 | $const->value = PrintUtil::expr($node->value);
66 |
67 | if (isset($doc->tags['var'])) {
68 | $const->type = $doc->tags['var']->type;
69 | }
70 |
71 | return $const;
72 | }
73 |
74 | /**
75 | * @param \PhpParser\Node\Stmt\Function_ $node Function node
76 | * @param \Cake\ApiDocs\Reflection\Context $context Reflection context
77 | * @param \Cake\ApiDocs\Reflection\Source $source Reflection source
78 | * @return \Cake\ApiDocs\Reflection\ReflectedDefine
79 | */
80 | public function createFunction(Function_ $node, Context $context, Source $source): ReflectedFunction
81 | {
82 | $doc = new DocBlock($node->getDocComment()?->getText());
83 |
84 | $func = new ReflectedFunction($node->name->name, $doc, $context, $source);
85 | $this->reflectFuncLike($func, $node, $doc);
86 |
87 | return $func;
88 | }
89 |
90 | /**
91 | * @param \PhpParser\Node\Stmt\Interface_ $node Interface node
92 | * @param \Cake\ApiDocs\Reflection\Context $context Reflection context
93 | * @param \Cake\ApiDocs\Reflection\Source $source Reflection source
94 | * @return \Cake\ApiDocs\Reflection\ReflectedDefine
95 | */
96 | public function createInterface(Interface_ $node, Context $context, Source $source): ReflectedInterface
97 | {
98 | $doc = new DocBlock($node->getDocComment()?->getText());
99 |
100 | $interface = new ReflectedInterface($node->name->name, $doc, $context, $source);
101 | $this->reflectClassLike($interface, $node);
102 |
103 | $interface->extends = array_map(fn($name) => (string)$name, $node->extends);
104 |
105 | return $interface;
106 | }
107 |
108 | /**
109 | * @param \PhpParser\Node\Stmt\Class_ $node Class node
110 | * @param \Cake\ApiDocs\Reflection\Context $context Reflection context
111 | * @param \Cake\ApiDocs\Reflection\Source $source Reflection source
112 | * @return \Cake\ApiDocs\Reflection\ReflectedDefine
113 | */
114 | public function createClass(Class_ $node, Context $context, Source $source): ReflectedClass
115 | {
116 | $doc = new DocBlock($node->getDocComment()?->getText());
117 |
118 | $class = new ReflectedClass($node->name->name, $doc, $context, $source);
119 | $this->reflectClassLike($class, $node);
120 |
121 | $class->abstract = $node->isAbstract();
122 | $class->final = $node->isFinal();
123 | $class->extends = (string)$node->extends ?: null;
124 | $class->implements = array_map(fn($name) => (string)$name, $node->implements);
125 |
126 | return $class;
127 | }
128 |
129 | /**
130 | * @param \PhpParser\Node\Stmt\Trait_ $node Trait node
131 | * @param \Cake\ApiDocs\Reflection\Context $context Reflection context
132 | * @param \Cake\ApiDocs\Reflection\Source $source Reflection source
133 | * @return \Cake\ApiDocs\Reflection\ReflectedDefine
134 | */
135 | public function createTrait(Trait_ $node, Context $context, Source $source): ReflectedTrait
136 | {
137 | $doc = new DocBlock($node->getDocComment()?->getText());
138 | $trait = new ReflectedTrait($node->name->name, $doc, $context, $source);
139 | $this->reflectClassLike($trait, $node);
140 |
141 | return $trait;
142 | }
143 |
144 | /**
145 | * @param \Cake\ApiDocs\Reflection\ReflectedClassLike $classLike Reflected classLike
146 | * @param \PhpParser\Node\Stmt\ClassConst $classNode Constant node
147 | * @param \PhpParser\Node\Const_ $constNode Constant node
148 | * @return \Cake\ApiDocs\Reflection\ReflectedDefine
149 | */
150 | protected function createConstant(
151 | ReflectedClassLike $classLike,
152 | ClassConst $classNode,
153 | Const_ $constNode
154 | ): ReflectedConstant {
155 | $doc = new DocBlock($classNode->getDocComment()?->getText());
156 | $source = new Source(
157 | $classLike->source->path,
158 | $classLike->source->inProject,
159 | $classNode->getStartLine(),
160 | $classNode->getEndLine()
161 | );
162 |
163 | $const = new ReflectedConstant(
164 | $constNode->name->name,
165 | $doc,
166 | $classLike->context,
167 | $source
168 | );
169 | $const->owner = $classLike;
170 |
171 | $const->value = PrintUtil::expr($constNode->value);
172 | if (isset($doc->tags['var'])) {
173 | $const->type = $doc->tags['var']->type;
174 | }
175 |
176 | $const->visibility = $classNode->isPublic() ? 'public' : ($classNode->isProtected() ? 'protected' : 'private');
177 |
178 | return $const;
179 | }
180 |
181 | /**
182 | * @param \Cake\ApiDocs\Reflection\ReflectedClassLike $classLike Reflected classLike
183 | * @param \PhpParser\Node\Stmt\Property $classNode Property node
184 | * @param \PhpParser\Node\Stmt\PropertyProperty $propNode Property node
185 | * @return \Cake\ApiDocs\Reflection\ReflectedDefine
186 | */
187 | protected function createProperty(
188 | ReflectedClassLike $classLike,
189 | Property $classNode,
190 | PropertyProperty $propNode
191 | ): ReflectedProperty {
192 | $doc = new DocBlock($classNode->getDocComment()?->getText());
193 | $source = new Source(
194 | $classLike->source->path,
195 | $classLike->source->inProject,
196 | $classNode->getStartLine(),
197 | $classNode->getEndLine()
198 | );
199 |
200 | $prop = new ReflectedProperty($propNode->name->name, $doc, $classLike->context, $source);
201 | $prop->owner = $classLike;
202 |
203 | $prop->nativeType = $classNode->type ? DocUtil::parseType(PrintUtil::node($classNode->type)) : null;
204 | $prop->type = $doc->tags['var']?->type ?? $prop->nativeType;
205 | $prop->default = $propNode->default ? PrintUtil::expr($propNode->default) : null;
206 |
207 | $prop->visibility = $classNode->isPublic() ? 'public' : ($classNode->isProtected() ? 'protected' : 'private');
208 | $prop->static = $classNode->isStatic();
209 |
210 | return $prop;
211 | }
212 |
213 | /**
214 | * @param \Cake\ApiDocs\Reflection\ReflectedClassLike $classLike Reflected classLike
215 | * @param string $tagName Property tag name
216 | * @param \PHPStan\PhpDocParser\Ast\PhpDoc\PropertyTagValueNode $tagValue Property tag value
217 | * @return \Cake\ApiDocs\Reflection\ReflectedProperty
218 | */
219 | protected function createdAnnotatedProperty(
220 | ReflectedClassLike $classLike,
221 | string $tagName,
222 | PropertyTagValueNode $tagValue
223 | ): ReflectedProperty {
224 | $doc = new DocBlock(null);
225 | $doc->summary = $tagValue->description;
226 | $source = clone $classLike->source;
227 |
228 | $prop = new ReflectedProperty(substr($tagValue->propertyName, 1), $doc, $classLike->context, $source);
229 | $prop->owner = $classLike;
230 | $prop->annotation = $tagName;
231 |
232 | $prop->nativeType = $tagValue->type;
233 | $prop->type = $tagValue->type;
234 |
235 | return $prop;
236 | }
237 |
238 | /**
239 | * @param \Cake\ApiDocs\Reflection\ReflectedClassLike $classLike Reflected classLike
240 | * @param \PhpParser\Node\Stmt\ClassMethod $node Method node
241 | * @return \Cake\ApiDocs\Reflection\ReflectedMethod
242 | */
243 | protected function createMethod(ReflectedClassLike $classLike, ClassMethod $node): ReflectedMethod
244 | {
245 | $doc = new DocBlock($node->getDocComment()?->getText());
246 | $source = new Source(
247 | $classLike->source->path,
248 | $classLike->source->inProject,
249 | $node->getStartLine(),
250 | $node->getEndLine()
251 | );
252 |
253 | $func = new ReflectedMethod(
254 | $node->name->name,
255 | $doc,
256 | $classLike->context,
257 | $source
258 | );
259 | $func->owner = $classLike;
260 |
261 | $this->reflectFuncLike($func, $node, $doc);
262 | $func->visibility = $node->isPublic() ? 'public' : ($node->isProtected() ? 'protected' : 'private');
263 | $func->abstract = $node->isAbstract();
264 | $func->static = $node->isStatic();
265 |
266 | return $func;
267 | }
268 |
269 | /**
270 | * @param \Cake\ApiDocs\Reflection\ReflectedClassLike $classLike Reflected classLike
271 | * @param string $tagName Method tag name
272 | * @param \PHPStan\PhpDocParser\Ast\PhpDoc\MethodTagValueNode $tagValue Method tag value
273 | * @return \Cake\ApiDocs\Reflection\ReflectedMethod
274 | */
275 | protected function createdAnnotatedMethod(
276 | ReflectedClassLike $classLike,
277 | string $tagName,
278 | MethodTagValueNode $tagValue
279 | ): ReflectedMethod {
280 | $doc = new DocBlock(null);
281 | $doc->summary = $tagValue->description;
282 | $source = clone $classLike->source;
283 |
284 | $method = new ReflectedMethod($tagValue->methodName, $doc, $classLike->context, $source);
285 | $method->owner = $classLike;
286 | $method->annotation = $tagName;
287 |
288 | foreach ($tagValue->parameters as $paramNode) {
289 | $param = new ReflectedParam(substr($paramNode->parameterName, 1));
290 | $param->type = $paramNode->type;
291 | $param->byRef = $paramNode->isReference;
292 | $param->variadic = $paramNode->isVariadic;
293 | $param->default = $paramNode->defaultValue?->__toString();
294 | $method->params[$param->name] = $param;
295 | }
296 | $method->returnType = $tagValue->returnType;
297 |
298 | return $method;
299 | }
300 |
301 | /**
302 | * @param \Cake\ApiDocs\Reflection\ReflectedClassLike $classLike Reflected classLike
303 | * @param \PhpParser\Node\Stmt\ClassLike $node ClassLike node
304 | * @return void
305 | */
306 | protected function reflectClassLike(ReflectedClassLike $classLike, ClassLike $node): void
307 | {
308 | foreach ($node->getConstants() as $classConstNode) {
309 | foreach ($classConstNode->consts as $constNode) {
310 | if (!$classConstNode->isPrivate()) {
311 | $constant = $this->createConstant($classLike, $classConstNode, $constNode);
312 | $classLike->constants[$constant->name] = $constant;
313 | }
314 | }
315 | }
316 | ksort($classLike->constants);
317 |
318 | foreach ($node->getProperties() as $classPropNode) {
319 | foreach ($classPropNode->props as $propNode) {
320 | if (!$classPropNode->isPrivate()) {
321 | $property = $this->createProperty($classLike, $classPropNode, $propNode);
322 | $classLike->properties[$property->name] = $property;
323 | }
324 | }
325 | }
326 | foreach (['@property', '@property-read', '@property-write'] as $tagName) {
327 | foreach ($classLike->doc->tags[$tagName] ?? [] as $tagValue) {
328 | $property = $this->createdAnnotatedProperty($classLike, $tagName, $tagValue);
329 | $classLike->properties[$property->name] = $property;
330 | }
331 | }
332 | ksort($classLike->properties);
333 |
334 | foreach ($node->getmethods() as $methodNode) {
335 | if (!$methodNode->isPrivate()) {
336 | $method = $this->createMethod($classLike, $methodNode);
337 | $classLike->methods[$method->name] = $method;
338 | }
339 | }
340 | foreach ($classLike->doc->tags['@method'] ?? [] as $tagValue) {
341 | $method = $this->createdAnnotatedMethod($classLike, '@method', $tagValue);
342 | $classLike->methods[$method->name] = $method;
343 | }
344 | ksort($classLike->methods);
345 |
346 | $traits = $node->getTraitUses();
347 | foreach ($traits as $trait) {
348 | foreach ($trait->traits as $use) {
349 | $classLike->uses[] = (string)$use;
350 | }
351 | }
352 | }
353 |
354 | /**
355 | * @param \Cake\ApiDocs\Reflection\ReflectedFunction $func Reflected function
356 | * @param \PhpParser\Node\FunctionLike $node Function node
357 | * @param \Cake\ApiDocs\Reflection\DocBlock $doc Reflected docblock
358 | * @return void
359 | */
360 | protected function reflectFuncLike(ReflectedFunction $func, FunctionLike $node, DocBlock $doc): void
361 | {
362 | $params = [];
363 | foreach ($node->getParams() as $paramNode) {
364 | $param = $this->createParam($func, $paramNode);
365 | $func->params[$param->name] = $param;
366 | }
367 |
368 | if ($node->getReturnType() !== null) {
369 | $func->nativeReturnType = DocUtil::parseType(PrintUtil::node($node->getReturnType()));
370 | }
371 | $func->returnType = $doc->tags['return']?->type ?? $func->nativeReturnType;
372 | $func->returnDescription = $doc->tags['return']?->description ?? '';
373 | }
374 |
375 | /**
376 | * @param \Cake\ApiDocs\Reflection\ReflectedFunction $func Reflected function
377 | * @param \PhpParser\Node\Param $node Param node
378 | * @return \Cake\ApiDocs\Reflection\ReflectedParam
379 | */
380 | protected function createParam(ReflectedFunction $func, Param $node): ReflectedParam
381 | {
382 | $param = new ReflectedParam($node->var->name);
383 |
384 | $tag = $this->getParamTag($param->name, $func->doc);
385 | $param->nativeType = $node->type ? DocUtil::parseType(PrintUtil::node($node->type)) : null;
386 | if ($tag) {
387 | $param->type = $tag->type;
388 | $param->description = $tag->description;
389 | } else {
390 | $param->type = $param->nativeType;
391 | }
392 |
393 | $param->variadic = $node->variadic;
394 | $param->byRef = $node->byRef;
395 | $param->default = $node->default ? PrintUtil::expr($node->default) : null;
396 |
397 | return $param;
398 | }
399 |
400 | /**
401 | * @param string $variable Variable name
402 | * @param \Cake\ApiDocs\Reflection\DocBlock $doc Reflected docblock
403 | * @return \PHPStan\PhpDocParser\Ast\PhpDoc\ParamTagValueNode|null
404 | */
405 | protected function getParamTag(string $variable, DocBlock $doc): ?ParamTagValueNode
406 | {
407 | $variable = '$' . $variable;
408 | foreach ($doc->tags['param'] ?? [] as $tag) {
409 | if ($tag instanceof InvalidTagValueNode) {
410 | continue;
411 | }
412 | if ($tag->parameterName === $variable) {
413 | return $tag;
414 | }
415 | }
416 |
417 | return null;
418 | }
419 | }
420 |
--------------------------------------------------------------------------------
8 |