├── .gitignore
├── .travis.yml
├── README.md
├── composer.json
├── lib
    ├── class-file-reflector.php
    ├── class-function-call-reflector.php
    ├── class-hook-reflector.php
    ├── class-method-call-reflector.php
    ├── class-static-method-call-reflector.php
    └── runner.php
├── phpunit.xml.dist
└── tests
    ├── phpunit
        ├── includes
        │   ├── bootstrap.php
        │   └── export-testcase.php
        └── tests
        │   └── export
        │       ├── docblocks.inc
        │       ├── docblocks.php
        │       ├── hooks.inc
        │       ├── hooks.php
        │       ├── namespace.inc
        │       ├── namespace.php
        │       └── uses
        │           ├── constructor.inc
        │           ├── constructor.php
        │           ├── methods.inc
        │           ├── methods.php
        │           ├── nested.inc
        │           └── nested.php
    └── source
        ├── actions.php
        ├── bad-class-doc.php
        ├── class-property-doc.php
        ├── class_method_doc.php
        ├── deprecated-file.php
        ├── filters.php
        ├── functions.php
        ├── good-class.php
        └── relationships.php


/.gitignore:
--------------------------------------------------------------------------------
1 | composer.lock
2 | vendor


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | sudo: false
 4 | 
 5 | matrix:
 6 |   include:
 7 |     - php: 7.1
 8 |     - php: 7.0
 9 |     - php: 5.6
10 |     - php: 5.5
11 |     - php: 5.4
12 |     - php: hhvm
13 | 
14 | before_install:
15 |     # Setup WP_TESTS_DIR (needed to bootstrap WP PHPUnit tests). 
16 |     - export WP_TESTS_DIR=/tmp/wordpress/tests/phpunit/
17 |     # Clone the WordPress develop repo.
18 |     - git clone --depth=1 --branch="4.3" git://develop.git.wordpress.org/ /tmp/wordpress/
19 |     # Setup DB.
20 |     - mysql -e "CREATE DATABASE wordpress_test;" -uroot
21 |     # Setup wp-config.
22 |     - cp /tmp/wordpress/wp-tests-config-sample.php /tmp/wordpress/wp-tests-config.php
23 |     - sed -i "s/youremptytestdbnamehere/wordpress_test/" /tmp/wordpress/wp-tests-config.php
24 |     - sed -i "s/yourusernamehere/root/" /tmp/wordpress/wp-tests-config.php
25 |     - sed -i "s/yourpasswordhere//" /tmp/wordpress/wp-tests-config.php
26 | 
27 | install: composer install --no-dev
28 | 
29 | script:
30 |   - phpunit
31 | 
32 | cache:
33 |   directories:
34 |     - vendor
35 |     - $HOME/.composer/cache
36 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # WP Parser Lib
 2 | 
 3 | This package contains the file scanning and hook parsing functionality from [WP Parser](https://github.com/WordPress/phpdoc-parser).
 4 | 
 5 | I did not write this code. I just abstracted it so it can be used independently of the WP Parser WordPress plugin.
 6 | 
 7 | ## Requirements
 8 | * PHP 5.4+
 9 | * [Composer](https://getcomposer.org/)
10 | 
11 | ## Installation
12 | 
13 | ```bash
14 | composer require wp-hooks/parser
15 | ```
16 | 
17 | ## Usage
18 | 
19 | ```php
20 | $files  = \WP_Parser\get_wp_files( $path );
21 | $output = \WP_Parser\parse_files( $files, $path );
22 | ```
23 | 
24 | See [wp-hooks/generator](https://github.com/wp-hooks/generator) as a full usage example.
25 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name"       : "wp-hooks/parser",
 3 | 	"description": "File scanning and hook parsing functionality from WP Parser.",
 4 | 	"keywords"   : ["wordpress"],
 5 | 	"homepage"   : "https://github.com/wp-hooks/parser",
 6 | 	"license"    : "GPL-2.0-or-later",
 7 | 	"authors"    : [
 8 | 		{
 9 | 			"name"    : "Ryan McCue",
10 | 			"homepage": "http://ryanmccue.info",
11 | 			"role"    : "Developer"
12 | 		},
13 | 		{
14 | 			"name"    : "Contributors",
15 | 			"homepage": "https://github.com/wp-hooks/parser/graphs/contributors"
16 | 		}
17 | 	],
18 | 	"support"    : {
19 | 		"issues": "https://github.com/wp-hooks/parser/issues"
20 | 	},
21 | 	"require"    : {
22 | 		"php"                      : ">=5.4",
23 | 		"composer/installers"      : "~1.0",
24 | 		"phpdocumentor/reflection" : "~3.0",
25 | 		"erusev/parsedown"         : "~1.7"
26 | 	},
27 | 	"autoload"   : {
28 | 		"classmap": ["lib"],
29 | 		"files"   : ["lib/runner.php"]
30 | 	},
31 | 	"config": {
32 | 		"allow-plugins": {
33 | 			"composer/installers": true
34 | 		}
35 | 	}
36 | }
37 | 


--------------------------------------------------------------------------------
/lib/class-file-reflector.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace WP_Parser;
  4 | 
  5 | use phpDocumentor\Reflection;
  6 | use phpDocumentor\Reflection\FileReflector;
  7 | 
  8 | /**
  9 |  * Reflection class for a full file.
 10 |  *
 11 |  * Extends the FileReflector from phpDocumentor to parse out WordPress
 12 |  * hooks and note function relationships.
 13 |  */
 14 | class File_Reflector extends FileReflector {
 15 | 	/**
 16 | 	 * List of elements used in global scope in this file, indexed by element type.
 17 | 	 *
 18 | 	 * @var array {
 19 | 	 *      @type Hook_Reflector[] $hooks     The action and filters.
 20 | 	 *      @type Function_Call_Reflector[] $functions The functions called.
 21 | 	 * }
 22 | 	 */
 23 | 	public $uses = array();
 24 | 
 25 | 	/**
 26 | 	 * List of elements used in the current class scope, indexed by method.
 27 | 	 *
 28 | 	 * @var array[][] {@see \WP_Parser\File_Reflector::$uses}
 29 | 	 */
 30 | 	protected $method_uses_queue = array();
 31 | 
 32 | 	/**
 33 | 	 * Stack of classes/methods/functions currently being parsed.
 34 | 	 *
 35 | 	 * @see \WP_Parser\FileReflector::getLocation()
 36 | 	 * @var \phpDocumentor\Reflection\BaseReflector[]
 37 | 	 */
 38 | 	protected $location = array();
 39 | 
 40 | 	/**
 41 | 	 * Last DocBlock associated with a non-documentable element.
 42 | 	 *
 43 | 	 * @var \PHPParser_Comment_Doc
 44 | 	 */
 45 | 	protected $last_doc = null;
 46 | 
 47 | 	/**
 48 | 	 * Add hooks to the queue and update the node stack when we enter a node.
 49 | 	 *
 50 | 	 * If we are entering a class, function or method, we push it to the location
 51 | 	 * stack. This is just so that we know whether we are in the file scope or not,
 52 | 	 * so that hooks in the main file scope can be added to the file.
 53 | 	 *
 54 | 	 * We also check function calls to see if there are any actions or hooks. If
 55 | 	 * there are, they are added to the file's hooks if in the global scope, or if
 56 | 	 * we are in a function/method, they are added to the queue. They will be
 57 | 	 * assigned to the function by leaveNode(). We also check for any other function
 58 | 	 * calls and treat them similarly, so that we can export a list of functions
 59 | 	 * used by each element.
 60 | 	 *
 61 | 	 * Finally, we pick up any docblocks for nodes that usually aren't documentable,
 62 | 	 * so they can be assigned to the hooks to which they may belong.
 63 | 	 *
 64 | 	 * @param \PHPParser_Node $node
 65 | 	 */
 66 | 	public function enterNode( \PHPParser_Node $node ) {
 67 | 		parent::enterNode( $node );
 68 | 
 69 | 		switch ( $node->getType() ) {
 70 | 			// Add classes, functions, and methods to the current location stack
 71 | 			case 'Stmt_Class':
 72 | 			case 'Stmt_Function':
 73 | 			case 'Stmt_ClassMethod':
 74 | 				array_push( $this->location, $node );
 75 | 				break;
 76 | 
 77 | 			// Parse out hook definitions and function calls and add them to the queue.
 78 | 			case 'Expr_FuncCall':
 79 | 				$function = new Function_Call_Reflector( $node, $this->context );
 80 | 
 81 | 				// Add the call to the list of functions used in this scope.
 82 | 				$this->getLocation()->uses['functions'][] = $function;
 83 | 
 84 | 				if ( $this->isFilter( $node ) ) {
 85 | 					if ( $this->last_doc && ! $node->getDocComment() ) {
 86 | 						$node->setAttribute( 'comments', array( $this->last_doc ) );
 87 | 						$this->last_doc = null;
 88 | 					}
 89 | 
 90 | 					$hook = new Hook_Reflector( $node, $this->context );
 91 | 
 92 | 					// Add it to the list of hooks used in this scope.
 93 | 					$this->getLocation()->uses['hooks'][] = $hook;
 94 | 				}
 95 | 				break;
 96 | 
 97 | 			// Parse out method calls, so we can export where methods are used.
 98 | 			case 'Expr_MethodCall':
 99 | 				$method = new Method_Call_Reflector( $node, $this->context );
100 | 
101 | 				// Add it to the list of methods used in this scope.
102 | 				$this->getLocation()->uses['methods'][] = $method;
103 | 				break;
104 | 
105 | 			// Parse out method calls, so we can export where methods are used.
106 | 			case 'Expr_StaticCall':
107 | 				$method = new Static_Method_Call_Reflector( $node, $this->context );
108 | 
109 | 				// Add it to the list of methods used in this scope.
110 | 				$this->getLocation()->uses['methods'][] = $method;
111 | 				break;
112 | 
113 | 			// Parse out `new Class()` calls as uses of Class::__construct().
114 | 			case 'Expr_New':
115 | 				$method = new \WP_Parser\Method_Call_Reflector( $node, $this->context );
116 | 
117 | 				// Add it to the list of methods used in this scope.
118 | 				$this->getLocation()->uses['methods'][] = $method;
119 | 				break;
120 | 		}
121 | 
122 | 		// Pick up DocBlock from non-documentable elements so that it can be assigned
123 | 		// to the next hook if necessary. We don't do this for name nodes, since even
124 | 		// though they aren't documentable, they still carry the docblock from their
125 | 		// corresponding class/constant/function/etc. that they are the name of. If
126 | 		// we don't ignore them, we'll end up picking up docblocks that are already
127 | 		// associated with a named element, and so aren't really from a non-
128 | 		// documentable element after all.
129 | 		if ( ! $this->isNodeDocumentable( $node ) && 'Name' !== $node->getType() && ( $docblock = $node->getDocComment() ) ) {
130 | 			$this->last_doc = $docblock;
131 | 		}
132 | 	}
133 | 
134 | 	/**
135 | 	 * Assign queued hooks to functions and update the node stack on leaving a node.
136 | 	 *
137 | 	 * We can now access the function/method reflectors, so we can assign any queued
138 | 	 * hooks to them. The reflector for a node isn't created until the node is left.
139 | 	 *
140 | 	 * @param \PHPParser_Node $node
141 | 	 */
142 | 	public function leaveNode( \PHPParser_Node $node ) {
143 | 
144 | 		parent::leaveNode( $node );
145 | 
146 | 		switch ( $node->getType() ) {
147 | 			case 'Stmt_Class':
148 | 				$class = end( $this->classes );
149 | 				if ( ! empty( $this->method_uses_queue ) ) {
150 | 					/** @var Reflection\ClassReflector\MethodReflector $method */
151 | 					foreach ( $class->getMethods() as $method ) {
152 | 						if ( isset( $this->method_uses_queue[ $method->getName() ] ) ) {
153 | 							if ( isset( $this->method_uses_queue[ $method->getName() ]['methods'] ) ) {
154 | 								/*
155 | 								 * For methods used in a class, set the class on the method call.
156 | 								 * That allows us to later get the correct class name for $this, self, parent.
157 | 								 */
158 | 								foreach ( $this->method_uses_queue[ $method->getName() ]['methods'] as $method_call ) {
159 | 									/** @var Method_Call_Reflector $method_call */
160 | 									$method_call->set_class( $class );
161 | 								}
162 | 							}
163 | 
164 | 							$method->uses = $this->method_uses_queue[ $method->getName() ];
165 | 						}
166 | 					}
167 | 				}
168 | 
169 | 				$this->method_uses_queue = array();
170 | 				array_pop( $this->location );
171 | 				break;
172 | 
173 | 			case 'Stmt_Function':
174 | 				$function = array_pop( $this->location );
175 | 				if ( isset( $function->uses ) && ! empty( $function->uses ) ) {
176 | 					end( $this->functions )->uses = $function->uses;
177 | 				}
178 | 				break;
179 | 
180 | 			case 'Stmt_ClassMethod':
181 | 				$method = array_pop( $this->location );
182 | 
183 | 				/*
184 | 				 * Store the list of elements used by this method in the queue. We'll
185 | 				 * assign them to the method upon leaving the class (see above).
186 | 				 */
187 | 				if ( ! empty( $method->uses ) ) {
188 | 					$this->method_uses_queue[ $method->name ] = $method->uses;
189 | 				}
190 | 				break;
191 | 		}
192 | 	}
193 | 
194 | 	/**
195 | 	 * @param \PHPParser_Node $node
196 | 	 *
197 | 	 * @return bool
198 | 	 */
199 | 	protected function isFilter( \PHPParser_Node $node ) {
200 | 		// Ignore variable functions
201 | 		if ( 'Name' !== $node->name->getType() ) {
202 | 			return false;
203 | 		}
204 | 
205 | 		$calling = (string) $node->name;
206 | 
207 | 		$functions = array(
208 | 			'apply_filters',
209 | 			'apply_filters_ref_array',
210 | 			'apply_filters_deprecated',
211 | 			'do_action',
212 | 			'do_action_ref_array',
213 | 			'do_action_deprecated',
214 | 		);
215 | 
216 | 		return in_array( $calling, $functions );
217 | 	}
218 | 
219 | 	/**
220 | 	 * @return File_Reflector
221 | 	 */
222 | 	protected function getLocation() {
223 | 		return empty( $this->location ) ? $this : end( $this->location );
224 | 	}
225 | 
226 | 	/**
227 | 	 * @param \PHPParser_Node $node
228 | 	 *
229 | 	 * @return bool
230 | 	 */
231 | 	protected function isNodeDocumentable( \PHPParser_Node $node ) {
232 | 		return parent::isNodeDocumentable( $node )
233 | 		|| ( $node instanceof \PHPParser_Node_Expr_FuncCall
234 | 			&& $this->isFilter( $node ) );
235 | 	}
236 | }
237 | 


--------------------------------------------------------------------------------
/lib/class-function-call-reflector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * A reflection class for a function call.
 5 |  */
 6 | 
 7 | namespace WP_Parser;
 8 | 
 9 | use phpDocumentor\Reflection\BaseReflector;
10 | 
11 | /**
12 |  * A reflection of a function call expression.
13 |  */
14 | class Function_Call_Reflector extends BaseReflector {
15 | 
16 | 	/**
17 | 	 * Returns the name for this Reflector instance.
18 | 	 *
19 | 	 * @return string
20 | 	 */
21 | 	public function getName() {
22 | 		if ( isset( $this->node->namespacedName ) ) {
23 | 			return '\\' . implode( '\\', $this->node->namespacedName->parts );
24 | 		}
25 | 
26 | 		$shortName = $this->getShortName();
27 | 
28 | 		if ( is_a( $shortName, 'PHPParser_Node_Name_FullyQualified' ) ) {
29 | 			return '\\' . (string) $shortName;
30 | 		}
31 | 
32 | 		if ( is_a( $shortName, 'PHPParser_Node_Name' ) ) {
33 | 			return (string) $shortName;
34 | 		}
35 | 
36 | 		/** @var \PHPParser_Node_Expr_ArrayDimFetch $shortName */
37 | 		if ( is_a( $shortName, 'PHPParser_Node_Expr_ArrayDimFetch' ) ) {
38 | 			$var = $shortName->var->name;
39 | 			$dim = $shortName->dim->name->parts[0];
40 | 
41 | 			return "\${$var}[{$dim}]";
42 | 		}
43 | 
44 | 		/** @var \PHPParser_Node_Expr_Variable $shortName */
45 | 		if ( is_a( $shortName, 'PHPParser_Node_Expr_Variable' ) ) {
46 | 			return $shortName->name;
47 | 		}
48 | 
49 | 		return (string) $shortName;
50 | 	}
51 | }
52 | 


--------------------------------------------------------------------------------
/lib/class-hook-reflector.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace WP_Parser;
  4 | 
  5 | use phpDocumentor\Reflection\BaseReflector;
  6 | use PHPParser_PrettyPrinter_Default;
  7 | 
  8 | /**
  9 |  * Custom reflector for WordPress hooks.
 10 |  */
 11 | class Hook_Reflector extends BaseReflector {
 12 | 
 13 | 	/**
 14 | 	 * @return string
 15 | 	 */
 16 | 	public function getName() {
 17 | 		$printer = new PHPParser_PrettyPrinter_Default;
 18 | 		return $this->cleanupName( $printer->prettyPrintExpr( $this->node->args[0]->value ) );
 19 | 	}
 20 | 
 21 | 	/**
 22 | 	 * @param string $name
 23 | 	 *
 24 | 	 * @return string
 25 | 	 */
 26 | 	private function cleanupName( $name ) {
 27 | 		$matches = array();
 28 | 
 29 | 		// quotes on both ends of a string
 30 | 		if ( preg_match( '/^[\'"]([^\'"]*)[\'"]$/', $name, $matches ) ) {
 31 | 			return $matches[1];
 32 | 		}
 33 | 
 34 | 		// two concatenated things, last one of them a variable
 35 | 		if ( preg_match(
 36 | 			'/(?:[\'"]([^\'"]*)[\'"]\s*\.\s*)?' . // First filter name string (optional)
 37 | 			'(\$[^\s]*)' .                        // Dynamic variable
 38 | 			'(?:\s*\.\s*[\'"]([^\'"]*)[\'"])?/',  // Second filter name string (optional)
 39 | 			$name, $matches ) ) {
 40 | 
 41 | 			if ( isset( $matches[3] ) ) {
 42 | 				return $matches[1] . '{' . $matches[2] . '}' . $matches[3];
 43 | 			} else {
 44 | 				return $matches[1] . '{' . $matches[2] . '}';
 45 | 			}
 46 | 		}
 47 | 
 48 | 		return $name;
 49 | 	}
 50 | 
 51 | 	/**
 52 | 	 * @return string
 53 | 	 */
 54 | 	public function getShortName() {
 55 | 		return $this->getName();
 56 | 	}
 57 | 
 58 | 	/**
 59 | 	 * @return string
 60 | 	 */
 61 | 	public function getType() {
 62 | 		$type = 'filter';
 63 | 		switch ( (string) $this->node->name ) {
 64 | 			case 'do_action':
 65 | 				$type = 'action';
 66 | 				break;
 67 | 			case 'do_action_ref_array':
 68 | 				$type = 'action_reference';
 69 | 				break;
 70 | 			case 'do_action_deprecated':
 71 | 				$type = 'action_deprecated';
 72 | 				break;
 73 | 			case 'apply_filters_ref_array':
 74 | 				$type = 'filter_reference';
 75 | 				break;
 76 | 			case 'apply_filters_deprecated';
 77 | 				$type = 'filter_deprecated';
 78 | 				break;
 79 | 		}
 80 | 
 81 | 		return $type;
 82 | 	}
 83 | 
 84 | 	/**
 85 | 	 * @return array
 86 | 	 */
 87 | 	public function getArgs() {
 88 | 		$printer = new Pretty_Printer;
 89 | 		$args    = array();
 90 | 		foreach ( $this->node->args as $arg ) {
 91 | 			$args[] = $printer->prettyPrintArg( $arg );
 92 | 		}
 93 | 
 94 | 		// Skip the filter name
 95 | 		array_shift( $args );
 96 | 
 97 | 		return $args;
 98 | 	}
 99 | }
100 | 


--------------------------------------------------------------------------------
/lib/class-method-call-reflector.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace WP_Parser;
  4 | 
  5 | use phpDocumentor\Reflection\BaseReflector;
  6 | use phpDocumentor\Reflection\ClassReflector;
  7 | 
  8 | /**
  9 |  * A reflection of a method call expression.
 10 |  */
 11 | class Method_Call_Reflector extends BaseReflector {
 12 | 
 13 | 	/**
 14 | 	 * The class that this method was called in, if it was called in a class.
 15 | 	 *
 16 | 	 * @var ClassReflector|false
 17 | 	 */
 18 | 	protected $called_in_class = false;
 19 | 
 20 | 	/**
 21 | 	 * Returns the name for this Reflector instance.
 22 | 	 *
 23 | 	 * @return string[] Index 0 is the calling instance, 1 is the method name.
 24 | 	 */
 25 | 	public function getName() {
 26 | 
 27 | 		if ( 'Expr_New' === $this->node->getType() ) {
 28 | 			$name = '__construct';
 29 | 			$caller = $this->node->class;
 30 | 		} else {
 31 | 			$name = $this->getShortName();
 32 | 			$caller = $this->node->var;
 33 | 		}
 34 | 
 35 | 		if ( $caller instanceof \PHPParser_Node_Expr ) {
 36 | 			$printer = new Pretty_Printer;
 37 | 			$caller = $printer->prettyPrintExpr( $caller );
 38 | 		} elseif ( $caller instanceof \PHPParser_Node_Name_FullyQualified ) {
 39 | 			$caller = '\\' . $caller->toString();
 40 | 		} elseif ( $caller instanceof \PHPParser_Node_Name ) {
 41 | 			$caller = $caller->toString();
 42 | 		}
 43 | 
 44 | 		$caller = $this->_resolveName( $caller );
 45 | 
 46 | 		// If the caller is a function, convert it to the function name
 47 | 		if ( is_a( $caller, 'PHPParser_Node_Expr_FuncCall' ) ) {
 48 | 
 49 | 			// Add parentheses to signify this is a function call
 50 | 			/** @var \PHPParser_Node_Expr_FuncCall $caller */
 51 | 			$caller = implode( '\\', $caller->name->parts ) . '()';
 52 | 		}
 53 | 
 54 | 		$class_mapping = $this->_getClassMapping();
 55 | 		if ( array_key_exists( $caller, $class_mapping ) ) {
 56 | 			$caller = $class_mapping[ $caller ];
 57 | 		}
 58 | 
 59 | 		return array( $caller, $name );
 60 | 	}
 61 | 
 62 | 	/**
 63 | 	 * Set the class that this method was called within.
 64 | 	 *
 65 | 	 * @param ClassReflector $class
 66 | 	 */
 67 | 	public function set_class( ClassReflector $class ) {
 68 | 
 69 | 		$this->called_in_class = $class;
 70 | 	}
 71 | 
 72 | 	/**
 73 | 	 * Returns whether or not this method call is a static call
 74 | 	 *
 75 | 	 * @return bool Whether or not this method call is a static call
 76 | 	 */
 77 | 	public function isStatic() {
 78 | 		return false;
 79 | 	}
 80 | 
 81 | 	/**
 82 | 	 * Returns a mapping from variable names to a class name, leverages globals for most used classes
 83 | 	 *
 84 | 	 * @return array Class mapping to map variable names to classes
 85 | 	 */
 86 | 	protected function _getClassMapping() {
 87 | 
 88 | 		// List of global use generated using following command:
 89 | 		// ack "global \\\$[^;]+;" --no-filename | tr -d '\t' | sort | uniq | sed "s/global //g" | sed "s/, /,/g" | tr , '\n' | sed "s/;//g" | sort | uniq | sed "s/\\\$//g" | sed "s/[^ ][^ ]*/'&' => ''/g"
 90 | 		// There is probably an easier way, there are currently no globals that are classes starting with an underscore
 91 | 		$wp_globals = array(
 92 | 			'authordata' => 'WP_User',
 93 | 			'custom_background' => 'Custom_Background',
 94 | 			'custom_image_header' => 'Custom_Image_Header',
 95 | 			'phpmailer' => 'PHPMailer',
 96 | 			'post' => 'WP_Post',
 97 | 			'userdata' => 'WP_User', // This can also be stdClass, but you can't call methods on an stdClass
 98 | 			'wp' => 'WP',
 99 | 			'wp_admin_bar' => 'WP_Admin_Bar',
100 | 			'wp_customize' => 'WP_Customize_Manager',
101 | 			'wp_embed' => 'WP_Embed',
102 | 			'wp_filesystem' => 'WP_Filesystem',
103 | 			'wp_hasher' => 'PasswordHash', // This can be overridden by plugins, for core assume this is ours
104 | 			'wp_json' => 'Services_JSON',
105 | 			'wp_list_table' => 'WP_List_Table', // This one differs because there are a lot of different List Tables, assume they all only overwrite existing functions on WP_List_Table
106 | 			'wp_locale' => 'WP_Locale',
107 | 			'wp_object_cache' => 'WP_Object_Cache',
108 | 			'wp_query' => 'WP_Query',
109 | 			'wp_rewrite' => 'WP_Rewrite',
110 | 			'wp_roles' => 'WP_Roles',
111 | 			'wp_scripts' => 'WP_Scripts',
112 | 			'wp_styles' => 'WP_Styles',
113 | 			'wp_the_query' => 'WP_Query',
114 | 			'wp_widget_factory' => 'WP_Widget_Factory',
115 | 			'wp_xmlrpc_server' => 'wp_xmlrpc_server', // This can be overridden by plugins, for core assume this is ours
116 | 			'wpdb' => 'wpdb',
117 | 		);
118 | 
119 | 		$wp_functions = array(
120 | 			'get_current_screen()' => 'WP_Screen',
121 | 			'_get_list_table()' => 'WP_List_Table', // This one differs because there are a lot of different List Tables, assume they all only overwrite existing functions on WP_List_Table
122 | 			'wp_get_theme()' => 'WP_Theme',
123 | 		);
124 | 
125 | 		$class_mapping = array_merge( $wp_globals, $wp_functions );
126 | 
127 | 		return $class_mapping;
128 | 	}
129 | 
130 | 	/**
131 | 	 * Resolve a class name from self/parent.
132 | 	 *
133 | 	 * @param string $class The class name.
134 | 	 *
135 | 	 * @return string The resolved class name.
136 | 	 */
137 | 	protected function _resolveName( $class ) {
138 | 
139 | 		if ( ! $this->called_in_class ) {
140 | 			return $class;
141 | 		}
142 | 
143 | 
144 | 		switch ( $class ) {
145 | 			case '$this':
146 | 			case 'self':
147 | 				$namespace = (string) $this->called_in_class->getNamespace();
148 | 				$namespace = ( 'global' !== $namespace ) ? $namespace . '\\' : '';
149 | 				$class = '\\' . $namespace . $this->called_in_class->getShortName();
150 | 				break;
151 | 			case 'parent':
152 | 				$class = '\\' . $this->called_in_class->getNode()->extends->toString();
153 | 				break;
154 | 		}
155 | 
156 | 		return $class;
157 | 	}
158 | }
159 | 


--------------------------------------------------------------------------------
/lib/class-static-method-call-reflector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace WP_Parser;
 4 | 
 5 | /**
 6 |  * A reflection of a method call expression.
 7 |  */
 8 | class Static_Method_Call_Reflector extends Method_Call_Reflector {
 9 | 
10 | 	/**
11 | 	 * Returns the name for this Reflector instance.
12 | 	 *
13 | 	 * @return string[] Index 0 is the class name, 1 is the method name.
14 | 	 */
15 | 	public function getName() {
16 | 		$class = $this->node->class;
17 | 		$prefix = ( is_a( $class, 'PHPParser_Node_Name_FullyQualified' ) ) ? '\\' : '';
18 | 		$class = $prefix . $this->_resolveName( implode( '\\', $class->parts ) );
19 | 
20 | 		return array( $class, $this->getShortName() );
21 | 	}
22 | 
23 | 	/**
24 | 	 * @return bool
25 | 	 */
26 | 	public function isStatic() {
27 | 		return true;
28 | 	}
29 | }
30 | 


--------------------------------------------------------------------------------
/lib/runner.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace WP_Parser;
  4 | 
  5 | use phpDocumentor\Reflection\BaseReflector;
  6 | use phpDocumentor\Reflection\ClassReflector\MethodReflector;
  7 | use phpDocumentor\Reflection\ClassReflector\PropertyReflector;
  8 | use phpDocumentor\Reflection\FunctionReflector;
  9 | use phpDocumentor\Reflection\FunctionReflector\ArgumentReflector;
 10 | use phpDocumentor\Reflection\ReflectionAbstract;
 11 | 
 12 | /**
 13 |  * @param string $directory
 14 |  *
 15 |  * @return array|\WP_Error
 16 |  */
 17 | function get_wp_files( $directory ) {
 18 | 	$iterableFiles = new \RecursiveIteratorIterator(
 19 | 		new \RecursiveDirectoryIterator( $directory )
 20 | 	);
 21 | 	$files         = array();
 22 | 
 23 | 	try {
 24 | 		foreach ( $iterableFiles as $file ) {
 25 | 			if ( 'php' !== $file->getExtension() ) {
 26 | 				continue;
 27 | 			}
 28 | 
 29 | 			$files[] = $file->getPathname();
 30 | 		}
 31 | 	} catch ( \UnexpectedValueException $exc ) {
 32 | 		return new \WP_Error(
 33 | 			'unexpected_value_exception',
 34 | 			sprintf( 'Directory [%s] contained a directory we can not recurse into', $directory )
 35 | 		);
 36 | 	}
 37 | 
 38 | 	return $files;
 39 | }
 40 | 
 41 | /**
 42 |  * @param array  $files
 43 |  * @param string $root
 44 |  *
 45 |  * @return array
 46 |  */
 47 | function parse_files( $files, $root ) {
 48 | 	$output = array();
 49 | 
 50 | 	foreach ( $files as $filename ) {
 51 | 		$file = new File_Reflector( $filename );
 52 | 
 53 | 		$path = ltrim( substr( $filename, strlen( $root ) ), DIRECTORY_SEPARATOR );
 54 | 		$file->setFilename( $path );
 55 | 
 56 | 		$file->process();
 57 | 
 58 | 		// TODO proper exporter
 59 | 		$out = array(
 60 | 			'file' => export_docblock( $file ),
 61 | 			'path' => str_replace( DIRECTORY_SEPARATOR, '/', $file->getFilename() ),
 62 | 			'root' => $root,
 63 | 		);
 64 | 
 65 | 		if ( ! empty( $file->uses ) ) {
 66 | 			$out['uses'] = export_uses( $file->uses );
 67 | 		}
 68 | 
 69 | 		foreach ( $file->getIncludes() as $include ) {
 70 | 			$out['includes'][] = array(
 71 | 				'name' => $include->getName(),
 72 | 				'line' => $include->getLineNumber(),
 73 | 				'type' => $include->getType(),
 74 | 			);
 75 | 		}
 76 | 
 77 | 		foreach ( $file->getConstants() as $constant ) {
 78 | 			$out['constants'][] = array(
 79 | 				'name'  => $constant->getShortName(),
 80 | 				'line'  => $constant->getLineNumber(),
 81 | 				'value' => $constant->getValue(),
 82 | 			);
 83 | 		}
 84 | 
 85 | 		if ( ! empty( $file->uses['hooks'] ) ) {
 86 | 			$out['hooks'] = export_hooks( $file->uses['hooks'] );
 87 | 		}
 88 | 
 89 | 		foreach ( $file->getFunctions() as $function ) {
 90 | 			$func = array(
 91 | 				'name'      => $function->getShortName(),
 92 | 				'namespace' => $function->getNamespace(),
 93 | 				'aliases'   => $function->getNamespaceAliases(),
 94 | 				'line'      => $function->getLineNumber(),
 95 | 				'end_line'  => $function->getNode()->getAttribute( 'endLine' ),
 96 | 				'arguments' => export_arguments( $function->getArguments() ),
 97 | 				'doc'       => export_docblock( $function ),
 98 | 				'hooks'     => array(),
 99 | 			);
100 | 
101 | 			if ( ! empty( $function->uses ) ) {
102 | 				$func['uses'] = export_uses( $function->uses );
103 | 
104 | 				if ( ! empty( $function->uses['hooks'] ) ) {
105 | 					$func['hooks'] = export_hooks( $function->uses['hooks'] );
106 | 				}
107 | 			}
108 | 
109 | 			$out['functions'][] = $func;
110 | 		}
111 | 
112 | 		foreach ( $file->getClasses() as $class ) {
113 | 			$class_data = array(
114 | 				'name'       => $class->getShortName(),
115 | 				'namespace'  => $class->getNamespace(),
116 | 				'line'       => $class->getLineNumber(),
117 | 				'end_line'   => $class->getNode()->getAttribute( 'endLine' ),
118 | 				'final'      => $class->isFinal(),
119 | 				'abstract'   => $class->isAbstract(),
120 | 				'extends'    => $class->getParentClass(),
121 | 				'implements' => $class->getInterfaces(),
122 | 				'properties' => export_properties( $class->getProperties() ),
123 | 				'methods'    => export_methods( $class->getMethods() ),
124 | 				'doc'        => export_docblock( $class ),
125 | 			);
126 | 
127 | 			$out['classes'][] = $class_data;
128 | 		}
129 | 
130 | 		$output[] = $out;
131 | 	}
132 | 
133 | 	return $output;
134 | }
135 | 
136 | /**
137 |  * Fixes newline handling in parsed text.
138 |  *
139 |  * DocBlock lines, particularly for descriptions, generally adhere to a given character width. For sentences and
140 |  * paragraphs that exceed that width, what is intended as a manual soft wrap (via line break) is used to ensure
141 |  * on-screen/in-file legibility of that text. These line breaks are retained by phpDocumentor. However, consumers
142 |  * of this parsed data may believe the line breaks to be intentional and may display the text as such.
143 |  *
144 |  * This function fixes text by merging consecutive lines of text into a single line. A special exception is made
145 |  * for text appearing in `<code>` and `<pre>` tags, as newlines appearing in those tags are always intentional.
146 |  *
147 |  * @param string $text
148 |  *
149 |  * @return string
150 |  */
151 | function fix_newlines( $text ) {
152 | 	// Non-naturally occurring string to use as temporary replacement.
153 | 	$replacement_string = '{{{{{}}}}}';
154 | 
155 | 	// Replace newline characters within 'code' and 'pre' tags with replacement string.
156 | 	$text = preg_replace_callback(
157 | 		"/(?<=<pre><code>)(.+)(?=<\/code><\/pre>)/s",
158 | 		function ( $matches ) use ( $replacement_string ) {
159 | 			return preg_replace( '/[\n\r]/', $replacement_string, $matches[1] );
160 | 		},
161 | 		$text
162 | 	);
163 | 
164 | 	// Merge consecutive non-blank lines together by replacing the newlines with a space.
165 | 	$text = preg_replace(
166 | 		"/[\n\r](?!\s*[\n\r])/m",
167 | 		' ',
168 | 		$text
169 | 	);
170 | 
171 | 	// Restore newline characters into code blocks.
172 | 	$text = str_replace( $replacement_string, "\n", $text );
173 | 
174 | 	return $text;
175 | }
176 | 
177 | /**
178 |  * @param BaseReflector|ReflectionAbstract $element
179 |  *
180 |  * @return array
181 |  */
182 | function export_docblock( $element ) {
183 | 	$docblock = $element->getDocBlock();
184 | 	if ( ! $docblock ) {
185 | 		return array(
186 | 			'description'      => '',
187 | 			'long_description' => '',
188 | 			'tags'             => array(),
189 | 		);
190 | 	}
191 | 
192 | 	$output = array(
193 | 		'description'      => preg_replace( '/[\n\r]+/', ' ', $docblock->getShortDescription() ),
194 | 		'long_description' => fix_newlines( $docblock->getLongDescription()->getFormattedContents() ),
195 | 		'tags'             => array(),
196 | 	);
197 | 
198 | 	foreach ( $docblock->getTags() as $tag ) {
199 | 		$tag_data = array(
200 | 			'name'    => $tag->getName(),
201 | 			'content' => preg_replace( '/[\n\r]+/', ' ', format_description( $tag->getDescription() ) ),
202 | 		);
203 | 		if ( method_exists( $tag, 'getTypes' ) ) {
204 | 			$tag_data['types'] = $tag->getTypes();
205 | 		}
206 | 		if ( method_exists( $tag, 'getLink' ) ) {
207 | 			$tag_data['link'] = $tag->getLink();
208 | 		}
209 | 		if ( method_exists( $tag, 'getVariableName' ) ) {
210 | 			$tag_data['variable'] = $tag->getVariableName();
211 | 		}
212 | 		if ( method_exists( $tag, 'getReference' ) ) {
213 | 			$tag_data['refers'] = $tag->getReference();
214 | 		}
215 | 		if ( method_exists( $tag, 'getVersion' ) ) {
216 | 			// Version string.
217 | 			$version = $tag->getVersion();
218 | 			if ( ! empty( $version ) ) {
219 | 				$tag_data['content'] = $version;
220 | 			}
221 | 			// Description string.
222 | 			if ( method_exists( $tag, 'getDescription' ) ) {
223 | 				$description = preg_replace( '/[\n\r]+/', ' ', format_description( $tag->getDescription() ) );
224 | 				if ( ! empty( $description ) ) {
225 | 					$tag_data['description'] = $description;
226 | 				}
227 | 			}
228 | 		}
229 | 		$output['tags'][] = $tag_data;
230 | 	}
231 | 
232 | 	return $output;
233 | }
234 | 
235 | /**
236 |  * @param Hook_Reflector[] $hooks
237 |  *
238 |  * @return array
239 |  */
240 | function export_hooks( array $hooks ) {
241 | 	$out = array();
242 | 
243 | 	foreach ( $hooks as $hook ) {
244 | 		$out[] = array(
245 | 			'name'      => $hook->getName(),
246 | 			'line'      => $hook->getLineNumber(),
247 | 			'end_line'  => $hook->getNode()->getAttribute( 'endLine' ),
248 | 			'type'      => $hook->getType(),
249 | 			'arguments' => $hook->getArgs(),
250 | 			'doc'       => export_docblock( $hook ),
251 | 		);
252 | 	}
253 | 
254 | 	return $out;
255 | }
256 | 
257 | /**
258 |  * @param ArgumentReflector[] $arguments
259 |  *
260 |  * @return array
261 |  */
262 | function export_arguments( array $arguments ) {
263 | 	$output = array();
264 | 
265 | 	foreach ( $arguments as $argument ) {
266 | 		$output[] = array(
267 | 			'name'    => $argument->getName(),
268 | 			'default' => $argument->getDefault(),
269 | 			'type'    => $argument->getType(),
270 | 		);
271 | 	}
272 | 
273 | 	return $output;
274 | }
275 | 
276 | /**
277 |  * @param PropertyReflector[] $properties
278 |  *
279 |  * @return array
280 |  */
281 | function export_properties( array $properties ) {
282 | 	$out = array();
283 | 
284 | 	foreach ( $properties as $property ) {
285 | 		$out[] = array(
286 | 			'name'        => $property->getName(),
287 | 			'line'        => $property->getLineNumber(),
288 | 			'end_line'    => $property->getNode()->getAttribute( 'endLine' ),
289 | 			'default'     => $property->getDefault(),
290 | //			'final' => $property->isFinal(),
291 | 			'static'      => $property->isStatic(),
292 | 			'visibility'  => $property->getVisibility(),
293 | 			'doc'         => export_docblock( $property ),
294 | 		);
295 | 	}
296 | 
297 | 	return $out;
298 | }
299 | 
300 | /**
301 |  * @param MethodReflector[] $methods
302 |  *
303 |  * @return array
304 |  */
305 | function export_methods( array $methods ) {
306 | 	$output = array();
307 | 
308 | 	foreach ( $methods as $method ) {
309 | 
310 | 		$method_data = array(
311 | 			'name'       => $method->getShortName(),
312 | 			'namespace'  => $method->getNamespace(),
313 | 			'aliases'    => $method->getNamespaceAliases(),
314 | 			'line'       => $method->getLineNumber(),
315 | 			'end_line'   => $method->getNode()->getAttribute( 'endLine' ),
316 | 			'final'      => $method->isFinal(),
317 | 			'abstract'   => $method->isAbstract(),
318 | 			'static'     => $method->isStatic(),
319 | 			'visibility' => $method->getVisibility(),
320 | 			'arguments'  => export_arguments( $method->getArguments() ),
321 | 			'doc'        => export_docblock( $method ),
322 | 		);
323 | 
324 | 		if ( ! empty( $method->uses ) ) {
325 | 			$method_data['uses'] = export_uses( $method->uses );
326 | 
327 | 			if ( ! empty( $method->uses['hooks'] ) ) {
328 | 				$method_data['hooks'] = export_hooks( $method->uses['hooks'] );
329 | 			}
330 | 		}
331 | 
332 | 		$output[] = $method_data;
333 | 	}
334 | 
335 | 	return $output;
336 | }
337 | 
338 | /**
339 |  * Export the list of elements used by a file or structure.
340 |  *
341 |  * @param array $uses {
342 |  *        @type Function_Call_Reflector[] $functions The functions called.
343 |  * }
344 |  *
345 |  * @return array
346 |  */
347 | function export_uses( array $uses ) {
348 | 	$out = array();
349 | 
350 | 	// Ignore hooks here, they are exported separately.
351 | 	unset( $uses['hooks'] );
352 | 
353 | 	foreach ( $uses as $type => $used_elements ) {
354 | 
355 | 		/** @var MethodReflector|FunctionReflector $element */
356 | 		foreach ( $used_elements as $element ) {
357 | 
358 | 			$name = $element->getName();
359 | 
360 | 			switch ( $type ) {
361 | 				case 'methods':
362 | 					$out[ $type ][] = array(
363 | 						'name'     => $name[1],
364 | 						'class'    => $name[0],
365 | 						'static'   => $element->isStatic(),
366 | 						'line'     => $element->getLineNumber(),
367 | 						'end_line' => $element->getNode()->getAttribute( 'endLine' ),
368 | 					);
369 | 					break;
370 | 
371 | 				default:
372 | 				case 'functions':
373 | 					$out[ $type ][] = array(
374 | 						'name'     => $name,
375 | 						'line'     => $element->getLineNumber(),
376 | 						'end_line' => $element->getNode()->getAttribute( 'endLine' ),
377 | 					);
378 | 
379 | 					if ( '_deprecated_file' === $name
380 | 						|| '_deprecated_function' === $name
381 | 						|| '_deprecated_argument' === $name
382 | 						|| '_deprecated_hook' === $name
383 | 					) {
384 | 						$arguments = $element->getNode()->args;
385 | 
386 | 						$out[ $type ][0]['deprecation_version'] = $arguments[1]->value->value;
387 | 					}
388 | 
389 | 					break;
390 | 			}
391 | 		}
392 | 	}
393 | 
394 | 	return $out;
395 | }
396 | 
397 | /**
398 |  * Format the given description with Markdown.
399 |  *
400 |  * @param string $description Description.
401 |  * @return string Description as Markdown if the Parsedown class exists, otherwise return
402 |  *                the given description text.
403 |  */
404 | function format_description( $description ) {
405 | 	if ( class_exists( 'Parsedown' ) ) {
406 | 		$parsedown   = \Parsedown::instance();
407 | 		$description = $parsedown->line( $description );
408 | 	}
409 | 	return $description;
410 | }
411 | 


--------------------------------------------------------------------------------
/phpunit.xml.dist:
--------------------------------------------------------------------------------
 1 | <phpunit
 2 | 	bootstrap="tests/phpunit/includes/bootstrap.php"
 3 | 	backupGlobals="false"
 4 | 	colors="true"
 5 | 	>
 6 | 	<testsuites>
 7 | 		<testsuite>
 8 | 			<directory suffix=".php">tests/phpunit/tests/</directory>
 9 | 		</testsuite>
10 | 	</testsuites>
11 | </phpunit>
12 | 


--------------------------------------------------------------------------------
/tests/phpunit/includes/bootstrap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | if ( ! getenv( 'WP_TESTS_DIR' ) ) {
 4 | 	exit( '$_ENV["WP_TESTS_DIR"] is not set.' . PHP_EOL );
 5 | }
 6 | 
 7 | include( __DIR__ . '/../../../vendor/autoload.php' );
 8 | 
 9 | /**
10 |  * The WordPress tests functions.
11 |  *
12 |  * Clearly, WP_TESTS_DIR should be the path to the WordPress PHPUnit tests checkout.
13 |  *
14 |  * We are loading this so that we can add our tests filter to load the plugin, using
15 |  * tests_add_filter().
16 |  *
17 |  * @since 1.0.0
18 |  */
19 | require_once getenv( 'WP_TESTS_DIR' ) . '/includes/functions.php';
20 | 
21 | tests_add_filter( 'muplugins_loaded', function() {
22 | 	$plugin_file = dirname( dirname( dirname( __DIR__ ) ) ) . '/plugin.php';
23 | 	include( $plugin_file );
24 | 	do_action( 'activate_' . plugin_basename( $plugin_file ) );
25 | });
26 | 
27 | /**
28 |  * Sets up the WordPress test environment.
29 |  *
30 |  * We've got our action set up, so we can load this now, and viola, the tests begin.
31 |  * Again, WordPress' PHPUnit test suite needs to be installed under the given path.
32 |  *
33 |  * @since 1.0.0
34 |  */
35 | require getenv( 'WP_TESTS_DIR' ) . '/includes/bootstrap.php';
36 | 
37 | include( __DIR__ . '/export-testcase.php' );
38 | include( __DIR__ . '/testcases/import.php' );
39 | 


--------------------------------------------------------------------------------
/tests/phpunit/includes/export-testcase.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * A parent test case class for the data export tests.
  5 |  */
  6 | 
  7 | namespace WP_Parser\Tests;
  8 | 
  9 | /**
 10 |  * Parent test case for data export tests.
 11 |  */
 12 | class Export_UnitTestCase extends \WP_UnitTestCase {
 13 | 
 14 | 	/**
 15 | 	 * The exported data.
 16 | 	 *
 17 | 	 * @var string
 18 | 	 */
 19 | 	protected $export_data;
 20 | 
 21 | 	/**
 22 | 	 * Parse the file for the current testcase.
 23 | 	 */
 24 | 	protected function parse_file() {
 25 | 
 26 | 		$class_reflector = new \ReflectionClass( $this );
 27 | 		$file = $class_reflector->getFileName();
 28 | 		$file = rtrim( $file, 'php' ) . 'inc';
 29 | 		$path = dirname( $file );
 30 | 
 31 | 		$export_data = \WP_Parser\parse_files( array( $file ), $path );
 32 | 
 33 | 		$this->export_data = $export_data[0];
 34 | 	}
 35 | 
 36 | 	/**
 37 | 	 * Parse the file to get the exported data before the first test.
 38 | 	 */
 39 | 	public function setUp() {
 40 | 
 41 | 		parent::setUp();
 42 | 
 43 | 		if ( ! $this->export_data ) {
 44 | 			$this->parse_file();
 45 | 		}
 46 | 	}
 47 | 
 48 | 	/**
 49 | 	 * Assert that an entity contains another entity.
 50 | 	 *
 51 | 	 * @param array  $entity   The exported entity data.
 52 | 	 * @param string $type     The type of thing that this entity should contain.
 53 | 	 * @param array  $expected The expected data for the thing the entity should contain.
 54 | 	 */
 55 | 	protected function assertEntityContains( $entity, $type, $expected ) {
 56 | 
 57 | 		$this->assertArrayHasKey( $type, $entity );
 58 | 
 59 | 		foreach ( $entity[ $type ] as $exported ) {
 60 | 			if ( $exported['line'] == $expected['line'] ) {
 61 | 				foreach ( $expected as $key => $expected_value ) {
 62 | 					$this->assertEquals( $expected_value, $exported[ $key ] );
 63 | 				}
 64 | 
 65 | 				return;
 66 | 			}
 67 | 		}
 68 | 
 69 | 		$this->fail( "No matching {$type} contained by {$entity['name']}." );
 70 | 	}
 71 | 
 72 | 	/**
 73 | 	 * Assert that a file contains the declaration of a hook.
 74 | 	 *
 75 | 	 * @param array $hook The expected export data for the hook.
 76 | 	 */
 77 | 	protected function assertFileContainsHook( $hook ) {
 78 | 
 79 | 		$this->assertEntityContains( $this->export_data, 'hooks', $hook );
 80 | 	}
 81 | 
 82 | 	/**
 83 | 	 * Assert that an entity uses another entity.
 84 | 	 *
 85 | 	 * @param array  $entity The exported entity data.
 86 | 	 * @param string $type   The type of thing that this entity should use.
 87 | 	 * @param array  $used   The expected data for the thing the entity should use.
 88 | 	 */
 89 | 	protected function assertEntityUses( $entity, $type, $used ) {
 90 | 
 91 | 		if ( ! $this->entity_uses( $entity, $type, $used ) ) {
 92 | 
 93 | 			$name = isset( $entity['path'] ) ? $entity['path'] : $entity['name'];
 94 | 
 95 | 			$this->fail( "No matching {$type} used by {$name}." );
 96 | 		}
 97 | 	}
 98 | 
 99 | 	/**
100 | 	 * Assert that an entity doesn't use another entity.
101 | 	 *
102 | 	 * @param array  $entity The exported entity data.
103 | 	 * @param string $type   The type of thing that this entity shouldn't use.
104 | 	 * @param array  $used   The expected data for the thing the entity shouldn't use.
105 | 	 */
106 | 	protected function assertEntityNotUses( $entity, $type, $used ) {
107 | 
108 | 		if ( $this->entity_uses( $entity, $type, $used ) ) {
109 | 
110 | 			$name = isset( $entity['path'] ) ? $entity['path'] : $entity['name'];
111 | 
112 | 			$this->fail( "Matching {$type} used by {$name}." );
113 | 		}
114 | 	}
115 | 
116 | 	/**
117 | 	 * Assert that a function uses another entity.
118 | 	 *
119 | 	 * @param string $type          The type of entity. E.g. 'functions', 'methods'.
120 | 	 * @param string $function_name The name of the function that uses this function.
121 | 	 * @param array  $entity        The expected exported data for the used entity.
122 | 	 */
123 | 	protected function assertFunctionUses( $type, $function_name, $entity ) {
124 | 
125 | 		$function_data = $this->find_entity_data_in(
126 | 			$this->export_data
127 | 			, 'functions'
128 | 			, $function_name
129 | 		);
130 | 
131 | 		$this->assertInternalType( 'array', $function_data );
132 | 		$this->assertEntityUses( $function_data, $type, $entity );
133 | 	}
134 | 
135 | 	/**
136 | 	 * Assert that a function doesn't use another entity.
137 | 	 *
138 | 	 * @param string $type          The type of entity. E.g. 'functions', 'methods'.
139 | 	 * @param string $function_name The name of the function that uses this function.
140 | 	 * @param array  $entity        The expected exported data for the used entity.
141 | 	 */
142 | 	protected function assertFunctionNotUses( $type, $function_name, $entity ) {
143 | 
144 | 		$function_data = $this->find_entity_data_in(
145 | 			$this->export_data
146 | 			, 'functions'
147 | 			, $function_name
148 | 		);
149 | 
150 | 		$this->assertInternalType( 'array', $function_data );
151 | 		$this->assertEntityNotUses( $function_data, $type, $entity );
152 | 	}
153 | 
154 | 	/**
155 | 	 * Assert that a method uses another entity.
156 | 	 *
157 | 	 * @param string $type        The type of entity. E.g. 'functions', 'methods'.
158 | 	 * @param string $class_name  The name of the class that the method is used in.
159 | 	 * @param string $method_name The name of the method that uses this method.
160 | 	 * @param array  $entity      The expected exported data for this entity.
161 | 	 */
162 | 	protected function assertMethodUses( $type, $class_name, $method_name, $entity ) {
163 | 
164 | 		$class_data = $this->find_entity_data_in(
165 | 			$this->export_data
166 | 			, 'classes'
167 | 			, $class_name
168 | 		);
169 | 
170 | 		$this->assertInternalType( 'array', $class_data );
171 | 
172 | 		$method_data = $this->find_entity_data_in(
173 | 			$class_data
174 | 			, 'methods'
175 | 			, $method_name
176 | 		);
177 | 
178 | 		$this->assertInternalType( 'array', $method_data );
179 | 		$this->assertEntityUses( $method_data, $type, $entity );
180 | 	}
181 | 
182 | 	/**
183 | 	 * Assert that a method doesn't use another entity.
184 | 	 *
185 | 	 * @param string $type        The type of entity. E.g. 'functions', 'methods'.
186 | 	 * @param string $class_name  The name of the class that the method is used in.
187 | 	 * @param string $method_name The name of the method that uses this method.
188 | 	 * @param array  $entity      The expected exported data for this entity.
189 | 	 */
190 | 	protected function assertMethodNotUses( $type, $class_name, $method_name, $entity ) {
191 | 
192 | 		$class_data = $this->find_entity_data_in(
193 | 			$this->export_data
194 | 			, 'classes'
195 | 			, $class_name
196 | 		);
197 | 
198 | 		$this->assertInternalType( 'array', $class_data );
199 | 
200 | 		$method_data = $this->find_entity_data_in(
201 | 			$class_data
202 | 			, 'methods'
203 | 			, $method_name
204 | 		);
205 | 
206 | 		$this->assertInternalType( 'array', $method_data );
207 | 		$this->assertEntityNotUses( $method_data, $type, $entity );
208 | 	}
209 | 
210 | 	/**
211 | 	 * Assert that a file uses a function.
212 | 	 *
213 | 	 * @param array $function The expected export data for the function.
214 | 	 */
215 | 	protected function assertFileUsesFunction( $function ) {
216 | 
217 | 		$this->assertEntityUses( $this->export_data, 'functions', $function );
218 | 	}
219 | 
220 | 	/**
221 | 	 * Assert that a function uses another function.
222 | 	 *
223 | 	 * @param string $function_name The name of the function that uses this function.
224 | 	 * @param array  $function      The expected exported data for the used function.
225 | 	 */
226 | 	protected function assertFunctionUsesFunction( $function_name, $function ) {
227 | 
228 | 		$this->assertFunctionUses( 'functions', $function_name, $function );
229 | 	}
230 | 
231 | 	/**
232 | 	 * Assert that a method uses a function.
233 | 	 *
234 | 	 * @param string $class_name  The name of the class that the method is used in.
235 | 	 * @param string $method_name The name of the method that uses this method.
236 | 	 * @param array  $function    The expected exported data for this function.
237 | 	 */
238 | 	protected function assertMethodUsesFunction( $class_name, $method_name, $function ) {
239 | 
240 | 		$this->assertMethodUses( 'functions', $class_name, $method_name, $function );
241 | 	}
242 | 
243 | 	/**
244 | 	 * Assert that a file uses a function.
245 | 	 *
246 | 	 * @param array $function The expected export data for the function.
247 | 	 */
248 | 	protected function assertFileNotUsesFunction( $function ) {
249 | 
250 | 		$this->assertEntityNotUses( $this->export_data, 'functions', $function );
251 | 	}
252 | 
253 | 	/**
254 | 	 * Assert that a function uses another function.
255 | 	 *
256 | 	 * @param string $function_name The name of the function that uses this function.
257 | 	 * @param array  $function      The expected exported data for the used function.
258 | 	 */
259 | 	protected function assertFunctionNotUsesFunction( $function_name, $function ) {
260 | 
261 | 		$this->assertFunctionNotUses( 'functions', $function_name, $function );
262 | 	}
263 | 
264 | 	/**
265 | 	 * Assert that a method uses a function.
266 | 	 *
267 | 	 * @param string $class_name  The name of the class that the method is used in.
268 | 	 * @param string $method_name The name of the method that uses this method.
269 | 	 * @param array  $function    The expected exported data for this function.
270 | 	 */
271 | 	protected function assertMethodNotUsesFunction( $class_name, $method_name, $function ) {
272 | 
273 | 		$this->assertMethodNotUses( 'functions', $class_name, $method_name, $function );
274 | 	}
275 | 
276 | 	/**
277 | 	 * Assert that a file uses an method.
278 | 	 *
279 | 	 * @param array $method The expected export data for the method.
280 | 	 */
281 | 	protected function assertFileUsesMethod( $method ) {
282 | 
283 | 		$this->assertEntityUses( $this->export_data, 'methods', $method );
284 | 	}
285 | 
286 | 	/**
287 | 	 * Assert that a function uses a method.
288 | 	 *
289 | 	 * @param string $function_name The name of the function that uses this method.
290 | 	 * @param array  $method        The expected exported data for this method.
291 | 	 */
292 | 	protected function assertFunctionUsesMethod( $function_name, $method ) {
293 | 
294 | 		$this->assertFunctionUses( 'methods', $function_name, $method );
295 | 	}
296 | 
297 | 	/**
298 | 	 * Assert that a method uses a method.
299 | 	 *
300 | 	 * @param string $class_name  The name of the class that the method is used in.
301 | 	 * @param string $method_name The name of the method that uses this method.
302 | 	 * @param array  $method      The expected exported data for this method.
303 | 	 */
304 | 	protected function assertMethodUsesMethod( $class_name, $method_name, $method ) {
305 | 
306 | 		$this->assertMethodUses( 'methods', $class_name, $method_name, $method );
307 | 	}
308 | 
309 | 	/**
310 | 	 * Assert that a file uses an method.
311 | 	 *
312 | 	 * @param array $method The expected export data for the method.
313 | 	 */
314 | 	protected function assertFileNotUsesMethod( $method ) {
315 | 
316 | 		$this->assertEntityNotUses( $this->export_data, 'methods', $method );
317 | 	}
318 | 
319 | 	/**
320 | 	 * Assert that a function uses a method.
321 | 	 *
322 | 	 * @param string $function_name The name of the function that uses this method.
323 | 	 * @param array  $method        The expected exported data for this method.
324 | 	 */
325 | 	protected function assertFunctionNotUsesMethod( $function_name, $method ) {
326 | 
327 | 		$this->assertFunctionNotUses( 'methods', $function_name, $method );
328 | 	}
329 | 
330 | 	/**
331 | 	 * Assert that a method uses a method.
332 | 	 *
333 | 	 * @param string $class_name  The name of the class that the method is used in.
334 | 	 * @param string $method_name The name of the method that uses this method.
335 | 	 * @param array  $method      The expected exported data for this method.
336 | 	 */
337 | 	protected function assertMethodNotUsesMethod( $class_name, $method_name, $method ) {
338 | 
339 | 		$this->assertMethodNotUses( 'methods', $class_name, $method_name, $method );
340 | 	}
341 | 
342 | 	/**
343 | 	 * Assert that an entity has a docblock.
344 | 	 *
345 | 	 * @param array  $entity  The exported entity data.
346 | 	 * @param array  $docs    The expected data for the entity's docblock.
347 | 	 * @param string $doc_key The key in the entity array that should hold the docs.
348 | 	 */
349 | 	protected function assertEntityHasDocs( $entity, $docs, $doc_key = 'doc' ) {
350 | 
351 | 		$this->assertArrayHasKey( $doc_key, $entity );
352 | 
353 | 		foreach ( $docs as $key => $expected_value ) {
354 | 			$this->assertEquals( $expected_value, $entity[ $doc_key ][ $key ] );
355 | 		}
356 | 	}
357 | 
358 | 	/**
359 | 	 * Assert that a file has a docblock.
360 | 	 *
361 | 	 * @param array $docs The expected data for the file's docblock.
362 | 	 */
363 | 	protected function assertFileHasDocs( $docs ) {
364 | 
365 | 		$this->assertEntityHasDocs( $this->export_data, $docs, 'file' );
366 | 	}
367 | 
368 | 	/**
369 | 	 * Assert that a function has a docblock.
370 | 	 *
371 | 	 * @param array $func The function name.
372 | 	 * @param array $docs The expected data for the function's docblock.
373 | 	 */
374 | 	protected function assertFunctionHasDocs( $func, $docs ) {
375 | 
376 | 		$func = $this->find_entity_data_in( $this->export_data, 'functions', $func );
377 | 		$this->assertEntityHasDocs( $func, $docs );
378 | 	}
379 | 
380 | 	/**
381 | 	 * Assert that a class has a docblock.
382 | 	 *
383 | 	 * @param array $class The class name.
384 | 	 * @param array $docs  The expected data for the class's docblock.
385 | 	 */
386 | 	protected function assertClassHasDocs( $class, $docs ) {
387 | 
388 | 		$class = $this->find_entity_data_in( $this->export_data, 'classes', $class );
389 | 		$this->assertEntityHasDocs( $class, $docs );
390 | 	}
391 | 
392 | 	/**
393 | 	 * Assert that a method has a docblock.
394 | 	 *
395 | 	 * @param string $class  The name of the class that the method is used in.
396 | 	 * @param string $method The method name.
397 | 	 * @param array  $docs   The expected data for the method's docblock.
398 | 	 */
399 | 	protected function assertMethodHasDocs( $class, $method, $docs ) {
400 | 
401 | 		$class = $this->find_entity_data_in( $this->export_data, 'classes', $class );
402 | 		$this->assertInternalType( 'array', $class );
403 | 
404 | 		$method = $this->find_entity_data_in( $class, 'methods', $method );
405 | 		$this->assertEntityHasDocs( $method, $docs );
406 | 	}
407 | 
408 | 	/**
409 | 	 * Assert that a property has a docblock.
410 | 	 *
411 | 	 * @param string $class    The name of the class that the method is used in.
412 | 	 * @param string $property The property name.
413 | 	 * @param array  $docs     The expected data for the property's docblock.
414 | 	 */
415 | 	protected function assertPropertyHasDocs( $class, $property, $docs ) {
416 | 
417 | 		$class = $this->find_entity_data_in( $this->export_data, 'classes', $class );
418 | 		$this->assertInternalType( 'array', $class );
419 | 
420 | 		$property = $this->find_entity_data_in( $class, 'properties', $property );
421 | 		$this->assertEntityHasDocs( $property, $docs );
422 | 	}
423 | 
424 | 	/**
425 | 	 * Assert that a hook has a docblock.
426 | 	 *
427 | 	 * @param array $hook The hook name.
428 | 	 * @param array $docs The expected data for the hook's docblock.
429 | 	 */
430 | 	protected function assertHookHasDocs( $hook, $docs ) {
431 | 
432 | 		$hook = $this->find_entity_data_in( $this->export_data, 'hooks', $hook );
433 | 		$this->assertEntityHasDocs( $hook, $docs );
434 | 	}
435 | 
436 | 	/**
437 | 	 * Find the exported data for an entity.
438 | 	 *
439 | 	 * @param array  $data        The data to search in.
440 | 	 * @param string $type        The type of entity.
441 | 	 * @param string $entity_name The name of the function.
442 | 	 *
443 | 	 * @return array|false The data for the entity, or false if it couldn't be found.
444 | 	 */
445 | 	protected function find_entity_data_in( $data, $type, $entity ) {
446 | 
447 | 		if ( empty( $data[ $type ] ) ) {
448 | 			return false;
449 | 		}
450 | 
451 | 		foreach ( $data[ $type ] as $entity_data ) {
452 | 			if ( $entity_data['name'] === $entity ) {
453 | 				return $entity_data;
454 | 			}
455 | 		}
456 | 
457 | 		return false;
458 | 	}
459 | 
460 | 	/**
461 | 	 * Check if one entity uses another entity.
462 | 	 *
463 | 	 * @param array  $entity The exported entity data.
464 | 	 * @param string $type   The type of thing that this entity should use.
465 | 	 * @param array  $used   The expected data for the thing the entity should use.
466 | 	 *
467 | 	 * @return bool Whether the entity uses the other.
468 | 	 */
469 | 	function entity_uses( $entity, $type, $used ) {
470 | 
471 | 		if ( ! isset( $entity['uses'][ $type ] ) ) {
472 | 			return false;
473 | 		}
474 | 
475 | 		foreach ( $entity['uses'][ $type ] as $exported_used ) {
476 | 			if ( $exported_used['line'] == $used['line'] ) {
477 | 				$this->assertEquals( $used, $exported_used );
478 | 				return true;
479 | 			}
480 | 		}
481 | 
482 | 		return false;
483 | 	}
484 | }
485 | 


--------------------------------------------------------------------------------
/tests/phpunit/tests/export/docblocks.inc:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This is the file-level docblock summary.
 5 |  *
 6 |  * This is the file-level docblock description, which may span multiple lines. In
 7 |  * fact, this one does. It spans more than two full lines, continuing on to the
 8 |  * third line.
 9 |  *
10 |  * @since 1.5.0
11 |  */
12 | 
13 | /**
14 |  * This is a function docblock.
15 |  *
16 |  * This function is just a test, but we've added this description anyway.
17 |  *
18 |  * @since 2.6.0
19 |  *
20 |  * @param string $var A string value.
21 |  * @param int    $num A number.
22 |  *
23 |  * @return bool Whether the function was called correctly.
24 |  */
25 | function test_func( $var, $num ) {
26 | 
27 | 	// In real life, there *might* be more stuff in here.
28 | 	return true;
29 | }
30 | 
31 | /**
32 |  * This is a class docblock.
33 |  *
34 |  * This is the more wordy description: This is a comment with two *'s at the start,
35 |  * which means that it is a doc comment. Docblock comments are comment blocks used
36 |  * to document code. This one documents the Test_Class class.
37 |  *
38 |  * @since 3.5.2
39 |  */
40 | class Test_Class {
41 | 
42 | 	/**
43 | 	 * This is a docblock for a class property.
44 | 	 *
45 | 	 * @since 3.0.0
46 | 	 *
47 | 	 * @var string
48 | 	 */
49 | 	public $a_string;
50 | 
51 | 	/**
52 | 	 * This is a method docblock.
53 | 	 *
54 | 	 * @since 4.5.0
55 | 	 *
56 | 	 * @param mixed $var A parameter.
57 | 	 * @param array $arr Another parameter.
58 | 	 *
59 | 	 * @return mixed The first param.
60 | 	 */
61 | 	public function test_method( $var, $arr ) {
62 | 		return $var;
63 | 	}
64 | }
65 | 
66 | /**
67 |  * A filter.
68 |  */
69 | $var = apply_filters( 'test_filter', $var );
70 | 
71 | /**
72 |  * A reference array filter.
73 |  */
74 | $var = apply_filters_ref_array( 'test_ref_array_filter', array( &$var ) );
75 | 
76 | /**
77 |  * A test action.
78 |  *
79 |  * @since 3.7.0
80 |  *
81 |  * @param WP_Post $post Post object.
82 |  */
83 | do_action( 'test_action', $post );
84 | 
85 | do_action( 'undocumented_hook' );
86 | 
87 | /**
88 |  * A reference array action.
89 |  */
90 | do_action_ref_array( 'test_ref_array_action', array( &$var ) );
91 | 


--------------------------------------------------------------------------------
/tests/phpunit/tests/export/docblocks.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * A test case for exporting docblocks.
  5 |  */
  6 | 
  7 | namespace WP_Parser\Tests;
  8 | 
  9 | /**
 10 |  * Test that docblocks are exported correctly.
 11 |  */
 12 | class Export_Docblocks extends Export_UnitTestCase {
 13 | 
 14 | 	/**
 15 | 	 * Test that line breaks are removed when the description is exported.
 16 | 	 */
 17 | 	public function test_linebreaks_removed() {
 18 | 
 19 | 		$this->assertStringMatchesFormat(
 20 | 			'%s'
 21 | 			, $this->export_data['classes'][0]['doc']['long_description']
 22 | 		);
 23 | 	}
 24 | 
 25 | 	/**
 26 | 	 * Test that hooks which aren't documented don't receive docs from another node.
 27 | 	 */
 28 | 	public function test_undocumented_hook() {
 29 | 
 30 | 		$this->assertHookHasDocs(
 31 | 			'undocumented_hook'
 32 | 			, array(
 33 | 				'description' => '',
 34 | 			)
 35 | 		);
 36 | 	}
 37 | 
 38 | 	/**
 39 | 	 * Test that hook docbloks are picked up.
 40 | 	 */
 41 | 	public function test_hook_docblocks() {
 42 | 
 43 | 		$this->assertHookHasDocs(
 44 | 			'test_action'
 45 | 			, array( 'description' => 'A test action.' )
 46 | 		);
 47 | 
 48 | 		$this->assertHookHasDocs(
 49 | 			'test_filter'
 50 | 			, array( 'description' => 'A filter.' )
 51 | 		);
 52 | 
 53 | 		$this->assertHookHasDocs(
 54 | 			'test_ref_array_action'
 55 | 			, array( 'description' => 'A reference array action.' )
 56 | 		);
 57 | 
 58 | 		$this->assertHookHasDocs(
 59 | 			'test_ref_array_filter'
 60 | 			, array( 'description' => 'A reference array filter.' )
 61 | 		);
 62 | 	}
 63 | 
 64 | 	/**
 65 | 	 * Test that file-level docs are exported.
 66 | 	 */
 67 | 	public function test_file_docblocks() {
 68 | 
 69 | 		$this->assertFileHasDocs(
 70 | 			array( 'description' => 'This is the file-level docblock summary.' )
 71 | 		);
 72 | 	}
 73 | 
 74 | 	/**
 75 | 	 * Test that function docs are exported.
 76 | 	 */
 77 | 	public function test_function_docblocks() {
 78 | 
 79 | 		$this->assertFunctionHasDocs(
 80 | 			'test_func'
 81 | 			, array(
 82 | 				'description' => 'This is a function docblock.',
 83 | 				'long_description' => '<p>This function is just a test, but we\'ve added this description anyway.</p>',
 84 | 				'tags' => array(
 85 | 					array(
 86 | 						'name' => 'since',
 87 | 						'content' => '2.6.0',
 88 | 					),
 89 | 					array(
 90 | 						'name' => 'param',
 91 | 						'content' => 'A string value.',
 92 | 						'types' => array( 'string' ),
 93 | 						'variable' => '$var',
 94 | 					),
 95 | 					array(
 96 | 						'name' => 'param',
 97 | 						'content' => 'A number.',
 98 | 						'types' => array( 'int' ),
 99 | 						'variable' => '$num',
100 | 					),
101 | 					array(
102 | 						'name' => 'return',
103 | 						'content' => 'Whether the function was called correctly.',
104 | 						'types' => array( 'bool' ),
105 | 					),
106 | 				),
107 | 			)
108 | 		);
109 | 	}
110 | 
111 | 	/**
112 | 	 * Test that class docs are exported.
113 | 	 */
114 | 	public function test_class_docblocks() {
115 | 
116 | 		$this->assertClassHasDocs(
117 | 			'Test_Class'
118 | 			, array( 'description' => 'This is a class docblock.' )
119 | 		);
120 | 	}
121 | 
122 | 	/**
123 | 	 * Test that method docs are exported.
124 | 	 */
125 | 	public function test_method_docblocks() {
126 | 
127 | 		$this->assertMethodHasDocs(
128 | 			'Test_Class'
129 | 			, 'test_method'
130 | 			, array( 'description' => 'This is a method docblock.' )
131 | 		);
132 | 	}
133 | 
134 | 	/**
135 | 	 * Test that function docs are exported.
136 | 	 */
137 | 	public function test_property_docblocks() {
138 | 
139 | 		$this->assertPropertyHasDocs(
140 | 			'Test_Class'
141 | 			, '$a_string'
142 | 			, array( 'description' => 'This is a docblock for a class property.' )
143 | 		);
144 | 	}
145 | }
146 | 


--------------------------------------------------------------------------------
/tests/phpunit/tests/export/hooks.inc:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | do_action( 'plain_action' );
4 | do_action( "action_with_double_quotes" );
5 | do_action( $variable . '-action' );
6 | do_action( "another-{$variable}-action" );
7 | do_action( 'hook_' . $object->property . '_pre' );
8 | 


--------------------------------------------------------------------------------
/tests/phpunit/tests/export/hooks.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * A test case for hook exporting.
 5 |  */
 6 | 
 7 | namespace WP_Parser\Tests;
 8 | 
 9 | /**
10 |  * Test that hooks are exported correctly.
11 |  */
12 | class Export_Hooks extends Export_UnitTestCase {
13 | 
14 | 	/**
15 | 	 * Test that hook names are standardized on export.
16 | 	 */
17 | 	public function test_hook_names_standardized() {
18 | 
19 | 		$this->assertFileContainsHook(
20 | 			array( 'name' => 'plain_action', 'line' => 3 )
21 | 		);
22 | 
23 | 		$this->assertFileContainsHook(
24 | 			array( 'name' => 'action_with_double_quotes', 'line' => 4 )
25 | 		);
26 | 
27 | 		$this->assertFileContainsHook(
28 | 			array( 'name' => '{$variable}-action', 'line' => 5 )
29 | 		);
30 | 
31 | 		$this->assertFileContainsHook(
32 | 			array( 'name' => 'another-{$variable}-action', 'line' => 6 )
33 | 		);
34 | 
35 | 		$this->assertFileContainsHook(
36 | 			array( 'name' => 'hook_{$object->property}_pre', 'line' => 7 )
37 | 		);
38 | 	}
39 | }
40 | 


--------------------------------------------------------------------------------
/tests/phpunit/tests/export/namespace.inc:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Awesome\Space;
4 | 
5 | function ohai() {}
6 | 


--------------------------------------------------------------------------------
/tests/phpunit/tests/export/namespace.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * A test case for hook exporting.
 5 |  */
 6 | 
 7 | namespace WP_Parser\Tests;
 8 | 
 9 | /**
10 |  * Test that hooks are exported correctly.
11 |  */
12 | class Export_Namespace extends Export_UnitTestCase {
13 | 
14 | 	/**
15 | 	 * Test that hook names are standardized on export.
16 | 	 */
17 | 	public function test_basic_namespace_support() {
18 | 		$expected = 'Awesome\\Space';
19 | 		$actual   = $this->export_data['functions'][0]['namespace'];
20 | 
21 | 		$this->assertEquals( $expected, $actual, 'Namespace should be parsed' );
22 | 	}
23 | }
24 | 


--------------------------------------------------------------------------------
/tests/phpunit/tests/export/uses/constructor.inc:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $query = new WP_Query();
 4 | 
 5 | function test() {
 6 | 	$a = new My_Class;
 7 | }
 8 | 
 9 | class My_Class extends Parent_Class {
10 | 
11 | 	static function instance() {
12 | 		return new self;
13 | 	}
14 | 
15 | 	static function parent() {
16 | 		return new parent;
17 | 	}
18 | }
19 | 
20 | $b = new $class;
21 | 


--------------------------------------------------------------------------------
/tests/phpunit/tests/export/uses/constructor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * A test case for exporting constructor method use.
 5 |  */
 6 | 
 7 | namespace WP_Parser\Tests;
 8 | 
 9 | /**
10 |  * Test that use of the __construct() method is exported for new Class() statements.
11 |  */
12 | class Export_Constructor_Use extends Export_UnitTestCase {
13 | 
14 | 	/**
15 | 	 * Test that use is exported when the class name is used explicitly.
16 | 	 */
17 | 	public function test_new_class() {
18 | 
19 | 		$this->assertFileUsesMethod(
20 | 			array(
21 | 				'name'     => '__construct',
22 | 				'line'     => 3,
23 | 				'end_line' => 3,
24 | 				'class'    => '\WP_Query',
25 | 				'static'   => false,
26 | 			)
27 | 		);
28 | 
29 | 		$this->assertFunctionUsesMethod(
30 | 			'test'
31 | 			, array(
32 | 				'name'     => '__construct',
33 | 				'line'     => 6,
34 | 				'end_line' => 6,
35 | 				'class'    => '\My_Class',
36 | 				'static'   => false,
37 | 			)
38 | 		);
39 | 	}
40 | 
41 | 	/**
42 | 	 * Test that use is exported when the self keyword is used.
43 | 	 */
44 | 	public function test_new_self() {
45 | 
46 | 		$this->assertMethodUsesMethod(
47 | 			'My_Class'
48 | 			, 'instance'
49 | 			, array(
50 | 				'name'     => '__construct',
51 | 				'line'     => 12,
52 | 				'end_line' => 12,
53 | 				'class'    => '\My_Class',
54 | 				'static'   => false,
55 | 			)
56 | 		);
57 | 	}
58 | 
59 | 	/**
60 | 	 * Test that use is exported when the parent keyword is used.
61 | 	 */
62 | 	public function test_new_parent() {
63 | 
64 | 		$this->assertMethodUsesMethod(
65 | 			'My_Class'
66 | 			, 'parent'
67 | 			, array(
68 | 				'name'     => '__construct',
69 | 				'line'     => 16,
70 | 				'end_line' => 16,
71 | 				'class'    => '\Parent_Class',
72 | 				'static'   => false,
73 | 			)
74 | 		);
75 | 	}
76 | 
77 | 	/**
78 | 	 * Test that use is exported when a variable is used.
79 | 	 */
80 | 	public function test_new_variable() {
81 | 
82 | 		$this->assertFileUsesMethod(
83 | 			array(
84 | 				'name'     => '__construct',
85 | 				'line'     => 20,
86 | 				'end_line' => 20,
87 | 				'class'    => '$class',
88 | 				'static'   => false,
89 | 			)
90 | 		);
91 | 	}
92 | }
93 | 


--------------------------------------------------------------------------------
/tests/phpunit/tests/export/uses/methods.inc:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | My_Class::static_method( $var );
 4 | 
 5 | $wpdb->update( $table, $data, $where );
 6 | 
 7 | function test() {
 8 | 	Another_Class::another_method();
 9 | 
10 | 	get_class()->call_method();
11 | }
12 | 
13 | class My_Class extends Parent_Class {
14 | 
15 | 	static function static_method() {
16 | 		Another_Class::do_static_stuff();
17 | 		self::do_stuff();
18 | 		$this->go();
19 | 		parent::do_parental_stuff();
20 | 	}
21 | }
22 | 


--------------------------------------------------------------------------------
/tests/phpunit/tests/export/uses/methods.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * A test case for exporting method use.
  5 |  */
  6 | 
  7 | namespace WP_Parser\Tests;
  8 | 
  9 | /**
 10 |  * Test that method use is exported correctly.
 11 |  */
 12 | class Export_Method_Use extends Export_UnitTestCase {
 13 | 
 14 | 	/**
 15 | 	 * Test that static method use is exported.
 16 | 	 */
 17 | 	public function test_static_methods() {
 18 | 
 19 | 		$this->assertFileUsesMethod(
 20 | 			array(
 21 | 				'name'     => 'static_method',
 22 | 				'line'     => 3,
 23 | 				'end_line' => 3,
 24 | 				'class'    => '\My_Class',
 25 | 				'static'   => true,
 26 | 			)
 27 | 		);
 28 | 
 29 | 		$this->assertFunctionUsesMethod(
 30 | 			'test'
 31 | 			, array(
 32 | 				'name'     => 'another_method',
 33 | 				'line'     => 8,
 34 | 				'end_line' => 8,
 35 | 				'class'    => '\Another_Class',
 36 | 				'static'   => true,
 37 | 			)
 38 | 		);
 39 | 
 40 | 		$this->assertMethodUsesMethod(
 41 | 			'My_Class'
 42 | 			, 'static_method'
 43 | 			, array(
 44 | 				'name'     => 'do_static_stuff',
 45 | 				'line'     => 16,
 46 | 				'end_line' => 16,
 47 | 				'class'    => '\Another_Class',
 48 | 				'static'   => true,
 49 | 			)
 50 | 		);
 51 | 
 52 | 		$this->assertMethodUsesMethod(
 53 | 			'My_Class'
 54 | 			, 'static_method'
 55 | 			, array(
 56 | 				'name'     => 'do_stuff',
 57 | 				'line'     => 17,
 58 | 				'end_line' => 17,
 59 | 				'class'    => '\My_Class',
 60 | 				'static'   => true,
 61 | 			)
 62 | 		);
 63 | 
 64 | 		$this->assertMethodUsesMethod(
 65 | 			'My_Class'
 66 | 			, 'static_method'
 67 | 			, array(
 68 | 				'name'     => 'do_parental_stuff',
 69 | 				'line'     => 19,
 70 | 				'end_line' => 19,
 71 | 				'class'    => '\Parent_Class',
 72 | 				'static'   => true,
 73 | 			)
 74 | 		);
 75 | 	}
 76 | 
 77 | 	/**
 78 | 	 * Test that instance method use is exported.
 79 | 	 */
 80 | 	public function test_instance_methods() {
 81 | 
 82 | 		$this->assertFileUsesMethod(
 83 | 			array(
 84 | 				'name'     => 'update',
 85 | 				'line'     => 5,
 86 | 				'end_line' => 5,
 87 | 				'class'    => '$wpdb',
 88 | 				'static'   => false,
 89 | 			)
 90 | 		);
 91 | 
 92 | 		$this->assertFunctionUsesMethod(
 93 | 			'test'
 94 | 			, array(
 95 | 				'name'     => 'call_method',
 96 | 				'line'     => 10,
 97 | 				'end_line' => 10,
 98 | 				'class'    => 'get_class()',
 99 | 				'static'   => false,
100 | 			)
101 | 		);
102 | 
103 | 		$this->assertMethodUsesMethod(
104 | 			'My_Class'
105 | 			, 'static_method'
106 | 			, array(
107 | 				'name'     => 'go',
108 | 				'line'     => 18,
109 | 				'end_line' => 18,
110 | 				'class'    => '\My_Class',
111 | 				'static'   => false,
112 | 			)
113 | 		);
114 | 	}
115 | }
116 | 


--------------------------------------------------------------------------------
/tests/phpunit/tests/export/uses/nested.inc:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | function test() {
 4 | 
 5 | 	a_function();
 6 | 
 7 | 	function sub_test() {
 8 | 
 9 | 		b_function();
10 | 
11 | 		My_Class::static_method();
12 | 	}
13 | 
14 | 	sub_test();
15 | 
16 | 	My_Class::do_things();
17 | }
18 | 
19 | class My_Class extends Parent_Class {
20 | 
21 | 	public function a_method() {
22 | 
23 | 		$this->do_it();
24 | 
25 | 		function sub_method_test() {
26 | 
27 | 			b_function();
28 | 
29 | 			My_Class::a_method();
30 | 		}
31 | 
32 | 		do_things();
33 | 	}
34 | }
35 | 


--------------------------------------------------------------------------------
/tests/phpunit/tests/export/uses/nested.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * A test case for exporting function use when one function is defined within another.
  5 |  */
  6 | 
  7 | namespace WP_Parser\Tests;
  8 | 
  9 | /**
 10 |  * Test that function use is exported correctly when function declarations are nested.
 11 |  */
 12 | class Export_Nested_Function_Use extends Export_UnitTestCase {
 13 | 
 14 | 	/**
 15 | 	 * Test that the uses data of the outer function is correct.
 16 | 	 */
 17 | 	public function test_top_function_uses_correct() {
 18 | 
 19 | 		$this->assertFunctionUsesFunction(
 20 | 			'test'
 21 | 			, array(
 22 | 				'name'     => 'a_function',
 23 | 				'line'     => 5,
 24 | 				'end_line' => 5,
 25 | 			)
 26 | 		);
 27 | 
 28 | 		$this->assertFunctionUsesFunction(
 29 | 			'test'
 30 | 			, array(
 31 | 				'name'     => 'sub_test',
 32 | 				'line'     => 14,
 33 | 				'end_line' => 14,
 34 | 			)
 35 | 		);
 36 | 
 37 | 		$this->assertFunctionUsesMethod(
 38 | 			'test'
 39 | 			, array(
 40 | 				'name'     => 'do_things',
 41 | 				'line'     => 16,
 42 | 				'end_line' => 16,
 43 | 				'class'    => '\My_Class',
 44 | 				'static'   => true,
 45 | 			)
 46 | 		);
 47 | 
 48 | 		$this->assertFunctionNotUsesFunction(
 49 | 			'test'
 50 | 			, array(
 51 | 				'name'     => 'b_function',
 52 | 				'line'     => 9,
 53 | 				'end_line' => 9,
 54 | 			)
 55 | 		);
 56 | 
 57 | 		$this->assertFunctionNotUsesMethod(
 58 | 			'test'
 59 | 			, array(
 60 | 				'name'     => 'static_method',
 61 | 				'line'     => 11,
 62 | 				'end_line' => 11,
 63 | 				'class'    => '\My_Class',
 64 | 				'static'   => true,
 65 | 			)
 66 | 		);
 67 | 	}
 68 | 
 69 | 	/**
 70 | 	 * Test that the usages of the nested function is correct.
 71 | 	 */
 72 | 	public function test_nested_function_uses_correct() {
 73 | 
 74 | 		$this->assertFunctionUsesFunction(
 75 | 			'sub_test'
 76 | 			, array(
 77 | 				'name'     => 'b_function',
 78 | 				'line'     => 9,
 79 | 				'end_line' => 9,
 80 | 			)
 81 | 		);
 82 | 
 83 | 		$this->assertFunctionUsesMethod(
 84 | 			'sub_test'
 85 | 			, array(
 86 | 				'name'     => 'static_method',
 87 | 				'line'     => 11,
 88 | 				'end_line' => 11,
 89 | 				'class'    => '\My_Class',
 90 | 				'static'   => true,
 91 | 			)
 92 | 		);
 93 | 
 94 | 		$this->assertFunctionNotUsesFunction(
 95 | 			'sub_test'
 96 | 			, array(
 97 | 				'name'     => 'a_function',
 98 | 				'line'     => 5,
 99 | 				'end_line' => 5,
100 | 			)
101 | 		);
102 | 
103 | 		$this->assertFunctionNotUsesFunction(
104 | 			'sub_test'
105 | 			, array(
106 | 				'name'     => 'sub_test',
107 | 				'line'     => 14,
108 | 				'end_line' => 14,
109 | 			)
110 | 		);
111 | 
112 | 		$this->assertFunctionNotUsesMethod(
113 | 			'sub_test'
114 | 			, array(
115 | 				'name'     => 'do_things',
116 | 				'line'     => 16,
117 | 				'end_line' => 16,
118 | 			)
119 | 		);
120 | 	}
121 | 
122 | 
123 | 	/**
124 | 	 * Test that the uses data of the outer method is correct.
125 | 	 */
126 | 	public function test_method_uses_correct() {
127 | 
128 | 		$this->assertMethodUsesMethod(
129 | 			'My_Class'
130 | 			, 'a_method'
131 | 			, array(
132 | 				'name'     => 'do_it',
133 | 				'line'     => 23,
134 | 				'end_line' => 23,
135 | 				'class'    => '\My_Class',
136 | 				'static'   => false,
137 | 			)
138 | 		);
139 | 
140 | 		$this->assertMethodUsesFunction(
141 | 			'My_Class'
142 | 			, 'a_method'
143 | 			, array(
144 | 				'name'     => 'do_things',
145 | 				'line'     => 32,
146 | 				'end_line' => 32,
147 | 			)
148 | 		);
149 | 
150 | 		$this->assertMethodNotUsesFunction(
151 | 			'My_Class'
152 | 			, 'a_method'
153 | 			, array(
154 | 				'name'     => 'b_function',
155 | 				'line'     => 27,
156 | 				'end_line' => 27,
157 | 			)
158 | 		);
159 | 
160 | 		$this->assertMethodNotUsesMethod(
161 | 			'My_Class'
162 | 			, 'a_method'
163 | 			, array(
164 | 				'name'     => 'a_method',
165 | 				'line'     => 29,
166 | 				'end_line' => 29,
167 | 				'class'    => '\My_Class',
168 | 				'static'   => true,
169 | 			)
170 | 		);
171 | 	}
172 | 
173 | 	/**
174 | 	 * Test that the usages of the nested function within a method is correct.
175 | 	 */
176 | 	public function test_nested_function_in_method_uses_correct() {
177 | 
178 | 		$this->assertFunctionUsesFunction(
179 | 			'sub_method_test'
180 | 			, array(
181 | 				'name'     => 'b_function',
182 | 				'line'     => 27,
183 | 				'end_line' => 27,
184 | 			)
185 | 		);
186 | 
187 | 		$this->assertFunctionUsesMethod(
188 | 			'sub_method_test'
189 | 			, array(
190 | 				'name'     => 'a_method',
191 | 				'line'     => 29,
192 | 				'end_line' => 29,
193 | 				'class'    => '\My_Class',
194 | 				'static'   => true,
195 | 			)
196 | 		);
197 | 
198 | 		$this->assertFunctionNotUsesMethod(
199 | 			'sub_method_test'
200 | 			, array(
201 | 				'name'     => 'do_it',
202 | 				'line'     => 23,
203 | 				'end_line' => 23,
204 | 				'class'    => '\My_Class',
205 | 				'static'   => false,
206 | 			)
207 | 		);
208 | 
209 | 		$this->assertFunctionNotUsesFunction(
210 | 			'sub_method_test'
211 | 			, array(
212 | 				'name'     => 'do_things',
213 | 				'line'     => 32,
214 | 				'end_line' => 32,
215 | 			)
216 | 		);
217 | 	}
218 | }
219 | 


--------------------------------------------------------------------------------
/tests/source/actions.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * This is a well documented action.
  5 |  *
  6 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
  7 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
  8 |  *
  9 |  * @since 2.9.0
 10 |  *
 11 |  * @param string $option Name of the option to update.
 12 |  * @param mixed $old_value The old option value.
 13 |  * @param mixed $value The new option value.
 14 |  */
 15 | do_action('good_doc_static_action', $option, $old_value, $value);
 16 | 
 17 | /**
 18 |  * This is a well documented dynamic action.
 19 |  *
 20 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 21 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
 22 |  *
 23 |  * @since 2.9.0
 24 |  *
 25 |  * @param string $option Name of the option to update.
 26 |  * @param mixed $old_value The old option value.
 27 |  * @param mixed $value The new option value.
 28 |  */
 29 | do_action('good_doc_dynamic_action_' . $option, $old_value, $value);
 30 | 
 31 | /**
 32 |  * This is a well documented dynamic action.
 33 |  *
 34 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 35 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
 36 |  *
 37 |  * @since 2.9.0
 38 |  *
 39 |  * @param string $option Name of the option to update.
 40 |  * @param mixed $old_value The old option value.
 41 |  * @param mixed $value The new option value.
 42 |  */
 43 | do_action("good_doc_double_quotes_dynamic_action_$option", $old_value, $value);
 44 | 
 45 | /**
 46 |  * This is an action missing the "since" line.
 47 |  *
 48 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 49 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
 50 |  *
 51 |  * @param string $option Name of the option to update.
 52 |  * @param mixed $old_value The old option value.
 53 |  * @param mixed $value The new option value.
 54 |  */
 55 | do_action('missing_since_static_action', $option, $old_value, $value);
 56 | 
 57 | /**
 58 |  * This is a dynamic action missing the "since" line.
 59 |  *
 60 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 61 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
 62 |  *
 63 |  * @param string $option Name of the option to update.
 64 |  * @param mixed $old_value The old option value.
 65 |  * @param mixed $value The new option value.
 66 |  */
 67 | do_action('missing_since_dynamic_action_' . $option, $old_value, $value);
 68 | 
 69 | /**
 70 |  * This is a dynamic action missing the "since" line.
 71 |  *
 72 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 73 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
 74 |  *
 75 |  * @param string $option Name of the option to update.
 76 |  * @param mixed $old_value The old option value.
 77 |  * @param mixed $value The new option value.
 78 |  */
 79 | do_action("missing_since_double_quotes_dynamic_action_$option", $old_value, $value);
 80 | 
 81 | /**
 82 |  * This is an action missing a "param" line.
 83 |  *
 84 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 85 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
 86 |  *
 87 |  * @since 2.9.0
 88 |  *
 89 |  * @param string $option Name of the option to update.
 90 |  * @param mixed $value The new option value.
 91 |  */
 92 | do_action('missing_param_static_action', $option, $old_value, $value);
 93 | 
 94 | /**
 95 |  * This is a well documented dynamic action.
 96 |  *
 97 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 98 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
 99 |  *
100 |  * @since 2.9.0
101 |  *
102 |  * @param string $option Name of the option to update.
103 |  * @param mixed $value The new option value.
104 |  */
105 | do_action('missing_param_dynamic_action_' . $option, $old_value, $value);
106 | 
107 | /**
108 |  * This is a well documented dynamic action.
109 |  *
110 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
111 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
112 |  *
113 |  * @since 2.9.0
114 |  *
115 |  * @param string $option Name of the option to update.
116 |  * @param mixed $value The new option value.
117 |  */
118 | do_action("missing_param_double_quotes_dynamic_action_$option", $old_value, $value);
119 | 
120 | do_action('no_doc_static_action', $option, $old_value, $value);
121 | do_action('no_doc_dynamic_action_' . $option, $old_value, $value);
122 | do_action("no_doc_double_quotes_dymanic_action_$option", $old_value, $value);
123 | 


--------------------------------------------------------------------------------
/tests/source/bad-class-doc.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * WordPress Error class.
 5 |  *
 6 |  * Container for checking for WordPress errors and error messages. Return
 7 |  * WP_Error and use {@link is_wp_error()} to check if this class is returned.
 8 |  * Many core WordPress functions pass this class in the event of an error and
 9 |  * if not handled properly will result in code errors.
10 |  *
11 |  * @package WordPress
12 |  */
13 | class No_Since_Class
14 | {
15 | }
16 | 
17 | /**
18 |  * WordPress Error class.
19 |  *
20 |  * Container for checking for WordPress errors and error messages. Return
21 |  * WP_Error and use {@link is_wp_error()} to check if this class is returned.
22 |  * Many core WordPress functions pass this class in the event of an error and
23 |  * if not handled properly will result in code errors.
24 |  *
25 |  * @since 2.1.0
26 |  */
27 | class No_Package_Class
28 | {
29 | }
30 | 
31 | /**
32 |  * @package WordPress
33 |  * @since 2.1.0
34 |  */
35 | class No_Description_Class
36 | {
37 | }


--------------------------------------------------------------------------------
/tests/source/class-property-doc.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * WordPress Error class.
 5 |  *
 6 |  * Container for checking for WordPress errors and error messages. Return
 7 |  * WP_Error and use {@link is_wp_error()} to check if this class is returned.
 8 |  * Many core WordPress functions pass this class in the event of an error and
 9 |  * if not handled properly will result in code errors.
10 |  *
11 |  * @package WordPress
12 |  * @since 2.1.0
13 |  */
14 | class Bad_Property_Doc
15 | {
16 |     /**
17 |      * Stores the list of errors.
18 |      *
19 |      * @since 2.1.0
20 |      * @var array
21 |      * @access private
22 |      */
23 |     private $private_good_doc_property = 'foo';
24 | 
25 |     /**
26 |      * @since 2.1.0
27 |      * @var array
28 |      * @access private
29 |      */
30 |     private $private_missing_description_property = 'string';
31 | 
32 |     /**
33 |      * Stores the list of errors.
34 |      *
35 |      * @var array
36 |      * @access private
37 |      */
38 |     private $private_missing_since_property = 'foo';
39 | 
40 |     /**
41 |      * Stores the list of errors.
42 |      *
43 |      * @since 2.1.0
44 |      * @access private
45 |      */
46 |     private $private_missing_var_property = 'foo';
47 | 
48 |     /**
49 |      * @since 2.1.0
50 |      * @var array
51 |      */
52 |     private $private_missing_access_property = 'string';
53 | 
54 |     /**
55 |      * Stores the list of errors.
56 |      *
57 |      * @since 2.1.0
58 |      * @var array
59 |      * @access public
60 |      */
61 |     public $public_good_doc_property = 'foo';
62 | 
63 |     /**
64 |      * @since 2.1.0
65 |      * @var array
66 |      * @access public
67 |      */
68 |     public $public_missing_description_property = 'string';
69 | 
70 |     /**
71 |      * Stores the list of errors.
72 |      *
73 |      * @var array
74 |      * @access public
75 |      */
76 |     public $public_missing_since_property = 'foo';
77 | 
78 |     /**
79 |      * Stores the list of errors.
80 |      *
81 |      * @since 2.1.0
82 |      * @access public
83 |      */
84 |     public $public_missing_var_property = 'foo';
85 | 
86 |     /**
87 |      * @since 2.1.0
88 |      * @var array
89 |      */
90 |     public $public_missing_access_property = 'string';
91 | }


--------------------------------------------------------------------------------
/tests/source/class_method_doc.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * This is a properly documented class.
  5 |  *
  6 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
  7 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
  8 |  *
  9 |  * @package WordPress
 10 |  * @since 2.1.0
 11 |  */
 12 | class Various_Method_Docs_Class
 13 | {
 14 |     /**
 15 |      * @since 2.1.0
 16 |      * @access public
 17 |      *
 18 |      * @see Function/method/class relied on
 19 |      * @link URL
 20 |      * @global type $varname Short description.
 21 |      *
 22 |      * @param string|int $code Error code
 23 |      * @param string $message Error message
 24 |      * @param mixed $data Optional. Error data.
 25 |      * @return WP_Error
 26 |      */
 27 |     public function public_method_missing_description($code = '', $message = '', $data = '')
 28 |     {
 29 |     }
 30 | 
 31 |     /**
 32 |      * Short description.
 33 |      *
 34 |      * Long description.
 35 |      *
 36 |      * @access public
 37 |      *
 38 |      * @see Function/method/class relied on
 39 |      * @link URL
 40 |      * @global type $varname Short description.
 41 |      *
 42 |      * @param string|int $code Error code
 43 |      * @param string $message Error message
 44 |      * @param mixed $data Optional. Error data.
 45 |      * @return WP_Error
 46 |      */
 47 |     public function public_method_missing_since($code = '', $message = '', $data = '')
 48 |     {
 49 |     }
 50 | 
 51 |     /**
 52 |      * Short description.
 53 |      *
 54 |      * Long description.
 55 |      *
 56 |      * @since 2.1.0
 57 |      * @access public
 58 |      *
 59 |      * @see Function/method/class relied on
 60 |      * @link URL
 61 |      * @global type $varname Short description.
 62 |      *
 63 |      * @return WP_Error
 64 |      */
 65 |     public function public_method_missing_param($code = '', $message = '', $data = '')
 66 |     {
 67 |     }
 68 | 
 69 |     /**
 70 |      * Short description.
 71 |      *
 72 |      * Long description.
 73 |      *
 74 |      * @since 2.1.0
 75 |      * @access public
 76 |      *
 77 |      * @see Function/method/class relied on
 78 |      * @link URL
 79 |      * @global type $varname Short description.
 80 |      *
 81 |      * @param string|int $code Error code
 82 |      * @param string $message Error message
 83 |      * @param mixed $data Optional. Error data.
 84 |      */
 85 |     public function public_method_missing_return($code = '', $message = '', $data = '')
 86 |     {
 87 |     }
 88 | 
 89 |     /**
 90 |      * Short description.
 91 |      *
 92 |      * Long description.
 93 |      *
 94 |      * @since 2.1.0
 95 |      *
 96 |      * @see Function/method/class relied on
 97 |      * @link URL
 98 |      * @global type $varname Short description.
 99 |      *
100 |      * @param string|int $code Error code
101 |      * @param string $message Error message
102 |      * @param mixed $data Optional. Error data.
103 |      * @return WP_Error
104 |      */
105 |     public function public_method_missing_access($code = '', $message = '', $data = '')
106 |     {
107 |     }
108 | 
109 |     /**
110 |      * Short description.
111 |      *
112 |      * Long description.
113 |      *
114 |      * @since 2.1.0
115 |      * @access public
116 |      *
117 |      * @link URL
118 |      * @global type $varname Short description.
119 |      *
120 |      * @param string|int $code Error code
121 |      * @param string $message Error message
122 |      * @param mixed $data Optional. Error data.
123 |      * @return WP_Error
124 |      */
125 |     public function public_method_missing_see($code = '', $message = '', $data = '')
126 |     {
127 |     }
128 | 
129 |     /**
130 |      * Short description.
131 |      *
132 |      * Long description.
133 |      *
134 |      * @since 2.1.0
135 |      * @access public
136 |      *
137 |      * @see Function/method/class relied on
138 |      * @global type $varname Short description.
139 |      *
140 |      * @param string|int $code Error code
141 |      * @param string $message Error message
142 |      * @param mixed $data Optional. Error data.
143 |      * @return WP_Error
144 |      */
145 |     public function public_method_missing_link($code = '', $message = '', $data = '')
146 |     {
147 |     }
148 | 
149 |     /**
150 |      * Short description.
151 |      *
152 |      * Long description.
153 |      *
154 |      * @since 2.1.0
155 |      * @access public
156 |      *
157 |      * @see Function/method/class relied on
158 |      * @link URL
159 |      *
160 |      * @param string|int $code Error code
161 |      * @param string $message Error message
162 |      * @param mixed $data Optional. Error data.
163 |      * @return WP_Error
164 |      */
165 |     public function public_method_missing_global($code = '', $message = '', $data = '')
166 |     {
167 |     }
168 | 
169 |     /**
170 |      * @since 2.1.0
171 |      * @access protected
172 |      *
173 |      * @see Function/method/class relied on
174 |      * @link URL
175 |      * @global type $varname Short description.
176 |      *
177 |      * @param string|int $code Error code
178 |      * @param string $message Error message
179 |      * @param mixed $data Optional. Error data.
180 |      * @return WP_Error
181 |      */
182 |     protected function protected_method_missing_description($code = '', $message = '', $data = '')
183 |     {
184 |     }
185 | 
186 |     /**
187 |      * Short description.
188 |      *
189 |      * Long description.
190 |      *
191 |      * @access protected
192 |      *
193 |      * @see Function/method/class relied on
194 |      * @link URL
195 |      * @global type $varname Short description.
196 |      *
197 |      * @param string|int $code Error code
198 |      * @param string $message Error message
199 |      * @param mixed $data Optional. Error data.
200 |      * @return WP_Error
201 |      */
202 |     protected function protected_method_missing_since($code = '', $message = '', $data = '')
203 |     {
204 |     }
205 | 
206 |     /**
207 |      * Short description.
208 |      *
209 |      * Long description.
210 |      *
211 |      * @since 2.1.0
212 |      * @access protected
213 |      *
214 |      * @see Function/method/class relied on
215 |      * @link URL
216 |      * @global type $varname Short description.
217 |      *
218 |      * @return WP_Error
219 |      */
220 |     protected function protected_method_missing_param($code = '', $message = '', $data = '')
221 |     {
222 |     }
223 | 
224 |     /**
225 |      * Short description.
226 |      *
227 |      * Long description.
228 |      *
229 |      * @since 2.1.0
230 |      * @access protected
231 |      *
232 |      * @see Function/method/class relied on
233 |      * @link URL
234 |      * @global type $varname Short description.
235 |      *
236 |      * @param string|int $code Error code
237 |      * @param string $message Error message
238 |      * @param mixed $data Optional. Error data.
239 |      */
240 |     protected function protected_method_missing_return($code = '', $message = '', $data = '')
241 |     {
242 |     }
243 | 
244 |     /**
245 |      * Short description.
246 |      *
247 |      * Long description.
248 |      *
249 |      * @since 2.1.0
250 |      *
251 |      * @see Function/method/class relied on
252 |      * @link URL
253 |      * @global type $varname Short description.
254 |      *
255 |      * @param string|int $code Error code
256 |      * @param string $message Error message
257 |      * @param mixed $data Optional. Error data.
258 |      * @return WP_Error
259 |      */
260 |     protected function protected_method_missing_access($code = '', $message = '', $data = '')
261 |     {
262 |     }
263 | 
264 |     /**
265 |      * Short description.
266 |      *
267 |      * Long description.
268 |      *
269 |      * @since 2.1.0
270 |      * @access protected
271 |      *
272 |      * @link URL
273 |      * @global type $varname Short description.
274 |      *
275 |      * @param string|int $code Error code
276 |      * @param string $message Error message
277 |      * @param mixed $data Optional. Error data.
278 |      * @return WP_Error
279 |      */
280 |     protected function protected_method_missing_see($code = '', $message = '', $data = '')
281 |     {
282 |     }
283 | 
284 |     /**
285 |      * Short description.
286 |      *
287 |      * Long description.
288 |      *
289 |      * @since 2.1.0
290 |      * @access protected
291 |      *
292 |      * @see Function/method/class relied on
293 |      * @global type $varname Short description.
294 |      *
295 |      * @param string|int $code Error code
296 |      * @param string $message Error message
297 |      * @param mixed $data Optional. Error data.
298 |      * @return WP_Error
299 |      */
300 |     protected function protected_method_missing_link($code = '', $message = '', $data = '')
301 |     {
302 |     }
303 | 
304 |     /**
305 |      * Short description.
306 |      *
307 |      * Long description.
308 |      *
309 |      * @since 2.1.0
310 |      * @access protected
311 |      *
312 |      * @see Function/method/class relied on
313 |      * @link URL
314 |      *
315 |      * @param string|int $code Error code
316 |      * @param string $message Error message
317 |      * @param mixed $data Optional. Error data.
318 |      * @return WP_Error
319 |      */
320 |     protected function protected_method_missing_global($code = '', $message = '', $data = '')
321 |     {
322 |     }
323 | 
324 |     /**
325 |      * @since 2.1.0
326 |      * @access private
327 |      *
328 |      * @see Function/method/class relied on
329 |      * @link URL
330 |      * @global type $varname Short description.
331 |      *
332 |      * @param string|int $code Error code
333 |      * @param string $message Error message
334 |      * @param mixed $data Optional. Error data.
335 |      * @return WP_Error
336 |      */
337 |     private function private_method_missing_description($code = '', $message = '', $data = '')
338 |     {
339 |     }
340 | 
341 |     /**
342 |      * Short description.
343 |      *
344 |      * Long description.
345 |      *
346 |      * @access private
347 |      *
348 |      * @see Function/method/class relied on
349 |      * @link URL
350 |      * @global type $varname Short description.
351 |      *
352 |      * @param string|int $code Error code
353 |      * @param string $message Error message
354 |      * @param mixed $data Optional. Error data.
355 |      * @return WP_Error
356 |      */
357 |     private function private_method_missing_since($code = '', $message = '', $data = '')
358 |     {
359 |     }
360 | 
361 |     /**
362 |      * Short description.
363 |      *
364 |      * Long description.
365 |      *
366 |      * @since 2.1.0
367 |      * @access private
368 |      *
369 |      * @see Function/method/class relied on
370 |      * @link URL
371 |      * @global type $varname Short description.
372 |      *
373 |      * @return WP_Error
374 |      */
375 |     private function private_method_missing_param($code = '', $message = '', $data = '')
376 |     {
377 |     }
378 | 
379 |     /**
380 |      * Short description.
381 |      *
382 |      * Long description.
383 |      *
384 |      * @since 2.1.0
385 |      * @access private
386 |      *
387 |      * @see Function/method/class relied on
388 |      * @link URL
389 |      * @global type $varname Short description.
390 |      *
391 |      * @param string|int $code Error code
392 |      * @param string $message Error message
393 |      * @param mixed $data Optional. Error data.
394 |      */
395 |     private function private_method_missing_return($code = '', $message = '', $data = '')
396 |     {
397 |     }
398 | 
399 |     /**
400 |      * Short description.
401 |      *
402 |      * Long description.
403 |      *
404 |      * @since 2.1.0
405 |      *
406 |      * @see Function/method/class relied on
407 |      * @link URL
408 |      * @global type $varname Short description.
409 |      *
410 |      * @param string|int $code Error code
411 |      * @param string $message Error message
412 |      * @param mixed $data Optional. Error data.
413 |      * @return WP_Error
414 |      */
415 |     private function private_method_missing_access($code = '', $message = '', $data = '')
416 |     {
417 |     }
418 | 
419 |     /**
420 |      * Short description.
421 |      *
422 |      * Long description.
423 |      *
424 |      * @since 2.1.0
425 |      * @access private
426 |      *
427 |      * @link URL
428 |      * @global type $varname Short description.
429 |      *
430 |      * @param string|int $code Error code
431 |      * @param string $message Error message
432 |      * @param mixed $data Optional. Error data.
433 |      * @return WP_Error
434 |      */
435 |     private function private_method_missing_see($code = '', $message = '', $data = '')
436 |     {
437 |     }
438 | 
439 |     /**
440 |      * Short description.
441 |      *
442 |      * Long description.
443 |      *
444 |      * @since 2.1.0
445 |      * @access private
446 |      *
447 |      * @see Function/method/class relied on
448 |      * @global type $varname Short description.
449 |      *
450 |      * @param string|int $code Error code
451 |      * @param string $message Error message
452 |      * @param mixed $data Optional. Error data.
453 |      * @return WP_Error
454 |      */
455 |     private function private_method_missing_link($code = '', $message = '', $data = '')
456 |     {
457 |     }
458 | 
459 |     /**
460 |      * Short description.
461 |      *
462 |      * Long description.
463 |      *
464 |      * @since 2.1.0
465 |      * @access private
466 |      *
467 |      * @see Function/method/class relied on
468 |      * @link URL
469 |      *
470 |      * @param string|int $code Error code
471 |      * @param string $message Error message
472 |      * @param mixed $data Optional. Error data.
473 |      * @return WP_Error
474 |      */
475 |     private function private_method_missing_global($code = '', $message = '', $data = '')
476 |     {
477 |     }
478 | }


--------------------------------------------------------------------------------
/tests/source/deprecated-file.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | _deprecated_file( 'deprecated-file.php', '1.0' );
 3 | 
 4 | /**
 5 | * This class should be marked as deprecated since 1.0
 6 | */
 7 | class Should_Be_Deprectated {
 8 | 
 9 | 	/**
10 | 	 * This method should be marked as deprecated since 1.0
11 | 	 */
12 | 	public function should_be_deprecated() {}
13 | }
14 | 
15 | /**
16 | * This function should be marked as deprecated since 1.0
17 | */
18 | function should_be_deprecated() {}
19 | 
20 | /**
21 | * This filter should be marked as deprecated since 1.0
22 | */
23 | $var = apply_filters( 'deprecated_filter', $var );
24 | 
25 | /**
26 | * This action should be marked as deprecated since 1.0
27 | */
28 | do_action( 'deprecated_action' );
29 | 


--------------------------------------------------------------------------------
/tests/source/filters.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * This is a well documented filter.
  4 |  *
  5 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
  6 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
  7 |  *
  8 |  * @since 3.9.0
  9 |  *
 10 |  * @param array $mce_translation Key/value pairs of strings.
 11 |  * @param string $mce_locale Locale.
 12 |  */
 13 | $mce_translation = apply_filters('good_static_filter', $mce_translation, $mce_locale);
 14 | 
 15 | /**
 16 |  * This is a well documented dynamic filter.
 17 |  *
 18 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 19 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
 20 |  *
 21 |  * @since 2.6.0
 22 |  *
 23 |  * @param mixed $value The new, unserialized option value.
 24 |  * @param mixed $old_value The old option value.
 25 |  */
 26 | $value = apply_filters('good_dynamic_filter_' . $option, $value, $old_value);
 27 | 
 28 | /**
 29 |  * This is a well documented dynamic filter.
 30 |  *
 31 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 32 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
 33 |  *
 34 |  * @since 2.6.0
 35 |  *
 36 |  * @param mixed $value The new, unserialized option value.
 37 |  * @param mixed $old_value The old option value.
 38 |  */
 39 | $value = apply_filters("good_double_quotes_dynamic_filter_$option", $value, $old_value);
 40 | 
 41 | /**
 42 |  * This is a filter missing the "since" line.
 43 |  *
 44 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 45 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
 46 |  *
 47 |  * @param mixed $value The new, unserialized option value.
 48 |  * @param string $mce_locale Locale.
 49 |  */
 50 | $mce_translation = apply_filters('missing_since_static_filter', $mce_translation, $mce_locale);
 51 | 
 52 | /**
 53 |  * This is a dynamic filter missing the "since" line.
 54 |  *
 55 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 56 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
 57 |  *
 58 |  * @param mixed $value The new, unserialized option value.
 59 |  * @param mixed $old_value The old option value.
 60 |  */
 61 | $value = apply_filters('missing_since_dynamic_filter_' . $option, $value, $old_value);
 62 | 
 63 | /**
 64 |  * This is a dynamic filter missing the "since" line.
 65 |  *
 66 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 67 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
 68 |  *
 69 |  * @param mixed $value The new, unserialized option value.
 70 |  * @param mixed $old_value The old option value.
 71 |  */
 72 | $value = apply_filters("missing_since_double_quotes_dynamic_filter_$option", $value, $old_value);
 73 | 
 74 | /**
 75 |  * This is a filter missing one "param" line.
 76 |  *
 77 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 78 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
 79 |  *
 80 |  * @since 2.6.0
 81 |  *
 82 |  * @param string $mce_locale Locale.
 83 |  */
 84 | $mce_translation = apply_filters('missing_param_static_filter', $mce_translation, $mce_locale);
 85 | 
 86 | /**
 87 |  * This is a dynamic filter missing one "param" line.
 88 |  *
 89 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 90 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
 91 |  *
 92 |  * @since 2.6.0
 93 |  *
 94 |  * @param string $mce_locale Locale.
 95 |  */
 96 | $value = apply_filters('missing_param_dynamic_filter_' . $option, $value, $old_value);
 97 | 
 98 | /**
 99 |  * This is a dynamic filter missing one "param" line.
100 |  *
101 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
102 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
103 |  *
104 |  * @since 2.6.0
105 |  *
106 |  * @param string $mce_locale Locale.
107 |  */
108 | $value = apply_filters("missing_param_double_quotes_dynamic_filter_$option", $value, $old_value);
109 | 
110 | /**
111 |  * This is a filter with multiple since tags
112 |  *
113 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
114 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
115 |  *
116 |  * @since 1.0
117 |  * @since 1.9 Added a new parameter to the filter
118 |  *
119 |  * @param string $first_parameter
120 |  * @param string $second_parameter
121 |  */
122 | $value = apply_filters( 'multiple_since_tags', $first_parameter, $second_parameter );
123 | 
124 | $mce_translation = apply_filters('no_doc_static_filter', $mce_translation, $mce_locale);
125 | 
126 | $value = apply_filters('no_doc_dynamic_filter_' . $option, $value, $old_value);
127 | 
128 | $value = apply_filters("no_doc_double_quotes_dynamic_filter_$option", $value, $old_value);
129 | 


--------------------------------------------------------------------------------
/tests/source/functions.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * Short description. (use period)
  5 |  *
  6 |  * Long description.
  7 |  *
  8 |  * @since 3.9.0
  9 |  *
 10 |  * @see Function/method/class relied on
 11 |  * @link URL
 12 |  * @global type $varname Short description.
 13 |  *
 14 |  * @param  type $thing Description.
 15 |  * @param  type $var Optional. Description.
 16 |  * @return type Description.
 17 |  */
 18 | function good_doc_function($thing, $var)
 19 | {
 20 | }
 21 | 
 22 | /**
 23 |  * Short description. (use period)
 24 |  *
 25 |  * @since 3.9.0
 26 |  *
 27 |  * @see Function/method/class relied on
 28 |  * @link URL
 29 |  * @global type $varname Short description.
 30 |  *
 31 |  * @param  type $thing Description.
 32 |  * @param  type $var Optional. Description.
 33 |  * @return type Description.
 34 |  */
 35 | function missing_long_description_function($thing, $var)
 36 | {
 37 | }
 38 | 
 39 | /**
 40 |  * @since 3.9.4
 41 |  *
 42 |  * @see Function/method/class relied on
 43 |  * @link URL
 44 |  * @global type $varname Short description.
 45 |  *
 46 |  * @param  type $thing Description.
 47 |  * @param  type $var Optional. Description.
 48 |  * @return type Description.
 49 |  */
 50 | function missing_description_function($thing, $var)
 51 | {
 52 | }
 53 | 
 54 | /**
 55 |  * Short description. (use period)
 56 |  *
 57 |  * Long description.
 58 |  *
 59 |  * @see Function/method/class relied on
 60 |  * @link URL
 61 |  * @global type $varname Short description.
 62 |  *
 63 |  * @param  type $thing Description.
 64 |  * @param  type $var Optional. Description.
 65 |  * @return type Description.
 66 |  */
 67 | function missing_since_function($thing, $var)
 68 | {
 69 | }
 70 | 
 71 | /**
 72 |  * Short description. (use period)
 73 |  *
 74 |  * Long description.
 75 |  *
 76 |  * @since 3.9.0
 77 |  *
 78 |  * @link URL
 79 |  * @global type $varname Short description.
 80 |  *
 81 |  * @param  type $thing Description.
 82 |  * @param  type $var Optional. Description.
 83 |  * @return type Description.
 84 |  */
 85 | function missing_see_function($thing, $var)
 86 | {
 87 | }
 88 | 
 89 | /**
 90 |  * Short description. (use period)
 91 |  *
 92 |  * Long description.
 93 |  *
 94 |  * @since 3.9.0
 95 |  *
 96 |  * @see Function/method/class relied on
 97 |  * @global type $varname Short description.
 98 |  *
 99 |  * @param  type $thing Description.
100 |  * @param  type $var Optional. Description.
101 |  * @return type Description.
102 |  */
103 | function missing_link_function($thing, $var)
104 | {
105 | }
106 | 
107 | /**
108 |  * Short description. (use period)
109 |  *
110 |  * Long description.
111 |  *
112 |  * @since 3.9.0
113 |  *
114 |  * @see Function/method/class relied on
115 |  * @link URL
116 |  *
117 |  * @param  type $thing Description.
118 |  * @param  type $var Optional. Description.
119 |  * @return type Description.
120 |  */
121 | function missing_global_function($thing, $var)
122 | {
123 | }
124 | 
125 | /**
126 |  * Short description. (use period)
127 |  *
128 |  * Long description.
129 |  *
130 |  * @since 3.9.0
131 |  *
132 |  * @see Function/method/class relied on
133 |  * @link URL
134 |  * @global type $varname Short description.
135 |  *
136 |  * @return type Description.
137 |  */
138 | function missing_param_function($thing, $var)
139 | {
140 | }
141 | 
142 | /**
143 |  * Short description. (use period)
144 |  *
145 |  * Long description.
146 |  *
147 |  * @since 3.9.0
148 |  *
149 |  * @see Function/method/class relied on
150 |  * @link URL
151 |  * @global type $varname Short description.
152 |  *
153 |  * @param  type $thing Description.
154 |  * @param  type $var Optional. Description.
155 |  */
156 | function missing_return_function($thing, $var)
157 | {
158 | }
159 | 


--------------------------------------------------------------------------------
/tests/source/good-class.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This is a properly documented class.
 5 |  *
 6 |  * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 7 |  * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
 8 |  *
 9 |  * @package WordPress
10 |  * @since 2.1.0
11 |  */
12 | class Good_Doc_Class
13 | {
14 |     /**
15 |      * This is a properly documented private property.
16 |      *
17 |      * @since 2.1.0
18 |      * @var array
19 |      * @access private
20 |      */
21 |     private $good_doc_private_property_from_good_doc_class = array();
22 | 
23 |     /**
24 |      * This is a properly documented protected property.
25 |      *
26 |      * @since 2.1.0
27 |      * @var array
28 |      * @access protected
29 |      */
30 |     protected $good_doc_protected_property_from_good_doc_class = array();
31 | 
32 |     /**
33 |      * This is a properly documented public property.
34 |      *
35 |      * @since 2.1.0
36 |      * @var array
37 |      * @access public
38 |      */
39 |     public $good_doc_public_property_from_good_doc_class = array();
40 | 
41 |     /**
42 |      * This is a properly documented public method.
43 |      *
44 |      * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
45 |      * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
46 |      *
47 |      * @since 2.1.0
48 |      *
49 |      * @param string|int $code Error code
50 |      * @param string $message Error message
51 |      * @param mixed $data Optional. Error data.
52 |      * @return WP_Error
53 |      */
54 |     public function good_doc_public_method_from_good_doc_class($code = '', $message = '', $data = '')
55 |     {
56 |     }
57 | 
58 |     /**
59 |      * This is a properly documented protected method.
60 |      *
61 |      * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
62 |      * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
63 |      *
64 |      * @since 2.1.0
65 |      *
66 |      * @param string|int $code Error code
67 |      * @param string $message Error message
68 |      * @param mixed $data Optional. Error data.
69 |      * @return WP_Error
70 |      */
71 |     protected function good_doc_protected_method_from_good_doc_class($code = '', $message = '', $data = '')
72 |     {
73 |     }
74 | 
75 |     /**
76 |      * This is a properly documented private method.
77 |      *
78 |      * Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
79 |      * Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
80 |      *
81 |      * @since 2.1.0
82 |      *
83 |      * @param string|int $code Error code
84 |      * @param string $message Error message
85 |      * @param mixed $data Optional. Error data.
86 |      * @return WP_Error
87 |      */
88 |     private function good_doc_private_method_from_good_doc_class($code = '', $message = '', $data = '')
89 |     {
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/tests/source/relationships.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | function relate_function1() {
 4 | 	relate_function2();
 5 | }
 6 | 
 7 | function relate_function2() {
 8 | 
 9 | 	/**
10 | 	 * A relationship hook
11 | 	 */
12 | 	$relate = apply_filters( 'relate-hook', true );
13 | 
14 | 	echo $relate;
15 | }
16 | 
17 | function relate_function3() {
18 | 	wpdb::relate_method1();
19 | }
20 | 
21 | function relate_function4() {
22 | 	$wpdb = new wpdb();
23 | 
24 | 	$wpdb->relate_method4();
25 | }
26 | 
27 | function relate_function5() {
28 | 	wpdb::relate_method2()->some_function();
29 | }
30 | 
31 | function relate_function6() {
32 | 	wp_screen()->relate_method1();
33 | }
34 | 
35 | class wpdb {
36 | 
37 | 	public function __construct() {}
38 | 
39 | 	public static function relate_method1() {
40 | 		self::relate_method2();
41 | 	}
42 | 
43 | 	public static function relate_method2() {
44 | 		/**
45 | 		 * Filter a aCustomize setting value in un-slashed form.
46 | 		 *
47 | 		 * @since 3.5.0
48 | 		 *
49 | 		 * @param mixed                $value Value of the setting.
50 | 		 * @param WP_Customize_Setting $this WP_Customize_Setting instance.
51 | 		 */
52 | 		$meh = apply_filters( 'meh-hook', $meh );
53 | 	}
54 | 
55 | 	public static function relate_method3() {
56 | 		relate_function1();
57 | 	}
58 | 
59 | 	public function relate_method4() {
60 | 		relate_function2();
61 | 	}
62 | 
63 | 	public function relate_method5() {
64 | 		$this->relate_method4();
65 | 	}
66 | 
67 | 	public static function relate_method6() {
68 | 		wpdb::relate_method1();
69 | 	}
70 | 
71 | 	public static function relate_method7() {
72 | 		global $wpdb;
73 | 
74 | 		$wpdb->relate_method5();
75 | 	}
76 | }
77 | 
78 | class WP_Screen {
79 | 	public function relate_method1() {}
80 | }
81 | 


--------------------------------------------------------------------------------