Context Navigation

jsdoc.module

Last change on this file was 483, checked in by hendrikvanantwerpen, 11 years ago
Added Dojo 1.9.3 release.
Property svn:executable set to ``*
File size: 85.4 KB

Rev	Line
[483]	1	<?php
	2	// $Id$
	3
	4	/**
	5	* @file
	6	* Documentation front-end for JavaScript projects.
	7	*
	8	* Allows JavaScript projects to parse their code and return an object structure
	9	* that will be used to generate custom Drupal nodes.
	10	*/
	11
	12	// Public API (intended for use in a JS source page)
	13	// =================================================
	14
	15	// Implemented global hook functions
	16	// =================================
	17
	18	/**
	19	* Implementation of hook_node_info().
	20	*/
	21	function jsdoc_node_info() {
	22	return array(
	23	'jsdoc_doc' => array('name' => t('Documentation'), 'module' => 'jsdoc_doc', 'description' => t('A JavaScript documentation file')),
	24	'jsdoc_object' => array('name' => t('JavaScript Object'), 'module' => 'jsdoc_object', 'description' => t('An implemented JavaScript object'))
	25	);
	26	}
	27
	28	/**
	29	* Implementation of hook_perm().
	30	*/
	31	function jsdoc_perm() {
	32	return array('edit jsdoc');
	33	}
	34
	35	/**
	36	* Implementation of hook_menu().
	37	*/
	38	function jsdoc_menu($may_cache) {
	39	$items = array();
	40	$version = isset($_SESSION['jsdoc_version']) ? $_SESSION['jsdoc_version'] : null;
	41
	42	if ($may_cache) {
	43	$items[] = array(
	44	'path' => 'admin/settings/jsdoc',
	45	'title' => t('JavaScript Documentation'),
	46	'callback' => 'drupal_get_form',
	47	'callback arguments' => array('jsdoc_admin'),
	48	'access' => user_access('access administration pages'),
	49	'type' => MENU_NORMAL_ITEM
	50	);
	51
	52	$items[] = array(
	53	'path' => 'jsdoc/jsonp',
	54	'type' => MENU_CALLBACK,
	55	'callback' => 'jsdoc_jsonp',
	56	'access' => true
	57	);
	58
	59	$items[] = array(
	60	'path' => 'jsdoc/feedback',
	61	'type' => MENU_CALLBACK,
	62	'callback' => 'jsdoc_feedback',
	63	'access' => true
	64	);
	65
	66	$items[] = array(
	67	'path' => 'jsdoc/feedback/review',
	68	'type' => MENU_CALLBACK,
	69	'callback' => 'jsdoc_feedback_review',
	70	'access' => true
	71	);
	72
	73	$items[] = array(
	74	'path' => 'jsdoc/404',
	75	'title' => t('Page not found'),
	76	'type' => MENU_CALLBACK,
	77	'callback' => 'jsdoc_404',
	78	'access' => true
	79	);
	80	}
	81	else {
	82	if (arg(0) == 'jsdoc' && arg(1) != 'jsonp') {
	83	$version = false;
	84	$resource = false;
	85	$name = '';
	86	$path = '';
	87
	88	$switch = false;
	89	$args = array();
	90	for ($i = 0; $arg = arg($i); $i++){
	91	if ($arg == '.switch') {
	92	$switch = arg($i + 1);
	93	break;
	94	}
	95	$args[] = $arg;
	96	}
	97
	98	if (count($args) == 4) {
	99	// Old URL
	100	$version = $args[2];
	101	$name = $args[3];
	102	drupal_goto("jsdoc/$version/$name");
	103	return;
	104	}
	105	if ($args[2]) {
	106	// If we have 2 arguments, assume that we don't have a resource or project
	107	// So basically, we assume that version is more important than project
	108	$version = $args[1];
	109	$name = $args[2];
	110	$path = "jsdoc/$version/$name";
	111	}
	112	elseif ($args[1]) {
	113	// Allow the user to only pass the name
	114	$name = $args[1];
	115	$path = "jsdoc/$name";
	116	}
	117
	118	$node = jsdoc_get_closest($name, $version);
	119
	120	if (!$node \|\| !$node->nid) {
	121	return;
	122	}
	123	else {
	124	jsdoc_current_node($node);
	125
	126	$item = array(
	127	'path' => $path,
	128	'title' => t('View'),
	129	'access' => node_access('view', $node),
	130	'type' => MENU_CALLBACK
	131	);
	132
	133	$version = jsdoc_get_version($node);
	134
	135	$path = array('jsdoc', $version->title, $name);
	136	if ($switch) {
	137	$path[1] = $switch;
	138	drupal_goto(implode('/', $path));
	139	return;
	140	}
	141
	142	$versions = jsdoc_get_versions($node, $name);
	143	if (count($versions) > 1) {
	144	$path = explode('/', $node->jsdoc_url);
	145	foreach (array_reverse($versions) as $release) {
	146	$path[2] = $release->title;
	147
	148	$items[] = array(
	149	'path' => $_GET['q'] . '/.switch/' . $release->title,
	150	'title' => $project->title . ' ' . $release->title,
	151	'type' => ($release->nid == $version->nid) ? MENU_DEFAULT_LOCAL_TASK : MENU_LOCAL_TASK
	152	);
	153	}
	154	}
	155
	156	$item['callback'] = ($name == $node->title) ? 'jsdoc_object_node_view' : 'jsdoc_child_node_view';
	157	$item['callback arguments'] = ($name == $node->title) ? array($node) : array($node, $name);
	158	}
	159	$items[] = $item;
	160	}
	161	}
	162
	163	return $items;
	164	}
	165
	166	/**
	167	* Impelementation of hook_block
	168	*/
	169	function jsdoc_block($op='list', $delta=0) {
	170	if ($op == 'list') {
	171	if (module_exists('search')) {
	172	$block[0]['info'] = t('JavaScript Documentation Search');
	173	}
	174	$block[1]['info'] = t('JavaScript Namespace List');
	175	return $block;
	176	}
	177	elseif ($op == 'view') {
	178	if ($delta == 0 && module_exists('search')) {
	179	$block['subject'] = 'Search';
	180	$block['content'] = preg_replace('%ignore.*endignore%s', theme('jsdoc_search', 'search'), drupal_get_form('_jsdoc_block_search'));
	181	return $block;
	182	}
	183	elseif ($delta == 1) {
	184	$namespaces = array();
	185
	186	$current = jsdoc_current_node();
	187	list($current_namespace,) = explode('.', $current->title, 2);
	188
	189	if (!($version = jsdoc_get_version($current))) {
	190	foreach (jsdoc_get_versions() as $version) {
	191	if ($version->title != 'HEAD') {
	192	break;
	193	}
	194	}
	195	}
	196
	197	if ($content = cache_get("jsdoc_namespaces_{$version->title}:$current_namespace")) {
	198	$content = $content->data;
	199	}
	200	else {
	201	$query = db_query("SELECT n.nid, n.title, version.title AS version FROM {node} AS n JOIN {jsdoc_objects} j ON (j.nid = n.nid) JOIN {node} AS version ON (version.nid = j.did) WHERE j.did = %d", $version->nid);
	202	while ($node = db_fetch_object($query)) {
	203	if (strpos($node->title, '._') !== false) {
	204	continue;
	205	}
	206	$parts = explode('.', $node->title);
	207	if (count($parts)) {
	208	for ($i = 1; $i <= count($parts); $i++) {
	209	$parent = implode('.', array_slice($parts, 0, $i));
	210	if (!$namespaces[$parent]) {
	211	$namespaces[$parent] = (object)array(
	212	'title' => $parent,
	213	'children' => array()
	214	);
	215	}
	216	}
	217
	218	array_pop($parts);
	219	$parent = implode('.', $parts);
	220	if ($parent) {
	221	$children = &$namespaces[$parent]->children;
	222	}
	223	else {
	224	$children = &$namespaces;
	225	}
	226	$children[$node->title]->jsdoc_url = 'jsdoc/' . $node->version . '/' . $node->title;
	227	$children[$node->title]->url = url('jsdoc/' . $node->version . '/' . $node->title);
	228	$children[$node->title]->a = l($node->title, 'jsdoc/' . $node->version . '/' . $node->title);
	229	}
	230	}
	231
	232	uksort($namespaces, 'strnatcasecmp');
	233	foreach ($namespaces as $namespace) {
	234	if ($namespace->children) {
	235	uksort($namespace->children, 'strnatcasecmp');
	236	}
	237	}
	238
	239	$content = theme('jsdoc_namespaces', $namespaces, $version->title, $current->title);
	240	cache_set("jsdoc_namespaces_{$version->title}:$current_namespace", 'cache', $content, time() + 86400);
	241	}
	242
	243	//$namespaces = unserialize(cache_get('jsdoc_namespaces', 'cache')->data);
	244	$block['subject'] = 'Objects';
	245	$block['content'] = $content;
	246	return $block;
	247	}
	248	}
	249	}
	250
	251	function _jsdoc_block_search() {
	252	if (module_exists('search')) {
	253	return array(
	254	'ignore' => array(
	255	'#value' => 'ignore'
	256	),
	257	'search' => array(
	258	'#type' => 'textfield'
	259	),
	260	'go' => array(
	261	'#type' => 'submit',
	262	'#value' => 'Go'
	263	),
	264	'endignore' => array(
	265	'#value' => 'endignore'
	266	)
	267	);
	268	}
	269	}
	270
	271	function _jsdoc_block_search_submit($form_id, $form) {
	272	// TODO
	273	$search = $form['search'];
	274	if (strpos($search, ' ') === false) {
	275	$query = db_query("SELECT title FROM {node} WHERE type = 'jsdoc_object' AND title = '%s' GROUP BY BINARY title", $search);
	276	if (db_num_rows($query) == 1) {
	277	$object = jsdoc_object_node_load(db_result($query));
	278	watchdog('search', t('%keys (@type).', array('%keys' => $search, '@type' => 'JavaScript Documentation')), WATCHDOG_NOTICE, l(t('result'), $object->jsdoc_url));
	279	drupal_goto($object->jsdoc_url);
	280	return;
	281	}
	282	else {
	283	$query = db_query("SELECT title FROM {node} WHERE type = 'jsdoc_object' AND title LIKE '%%%s%%' GROUP BY BINARY title", $search);
	284	if (db_num_rows($query) == 1) {
	285	$object = jsdoc_object_node_load(db_result($query));
	286	watchdog('search', t('%keys (@type).', array('%keys' => $search, '@type' => 'JavaScript Documentation')), WATCHDOG_NOTICE, l(t('result'), $object->jsdoc_url));
	287	drupal_goto($object->jsdoc_url);
	288	return;
	289	}
	290	}
	291	}
	292
	293	drupal_goto('search/jsdoc/' . $search);
	294	}
	295
	296	/**
	297	* shutdown function to make sure we always mark the last node processed.
	298	*/
	299	function jsdoc_update_shutdown() {
	300	global $jsdoc_last_change, $jsdoc_last_nid;
	301
	302	if ($jsdoc_last_change && $jsdoc_last_nid) {
	303	variable_set('jsdoc_cron_last', $jsdoc_last_change);
	304	variable_set('jsdoc_cron_last_nid', $jsdoc_last_nid);
	305	}
	306	}
	307
	308	/**
	309	* Implementation of hook_update_index().
	310	*
	311	* Handle node status the way that the node module does... through remembering nids, last change time,
	312	* and last comment change time.
	313	*
	314	* We need to save things by version/node pair though. That way, we can keep things so that the latest
	315	* update is always the latest version of the node.
	316	*/
	317	function jsdoc_update_index() {
	318	global $jsdoc_last_change, $jsdoc_last_nid;
	319
	320	register_shutdown_function('jsdoc_update_shutdown');
	321
	322	$jsdoc_last_change = variable_get('jsdoc_cron_last', 0);
	323	$jsdoc_last_nid = variable_get('jsdoc_cron_last_nid', 0);
	324	$limit = (int)variable_get('search_cron_limit', 500);
	325
	326	// $result = db_query_range("SELECT GREATEST(IF(c.last_comment_timestamp IS NULL, 0, c.last_comment_timestamp), n.changed) as last_change, n.nid FROM {node} n LEFT JOIN {node_comment_statistics} c ON n.nid = c.nid WHERE n.type = 'jsdoc_variable' AND n.status = 1 AND ((GREATEST(n.changed, c.last_comment_timestamp) = %d AND n.nid > %d) OR (n.changed > %d OR c.last_comment_timestamp > %d)) ORDER BY GREATEST(n.changed, c.last_comment_timestamp) ASC, n.nid ASC", $last, $last_nid, $last, $last, $last, 0, $limit);
	327	$result = db_query_range("SELECT n.changed as last_change, n.nid FROM {node} n WHERE n.type = 'jsdoc_object' AND ((n.changed = %d AND n.nid > %d) OR n.changed > %d) ORDER BY n.changed ASC, n.nid ASC", $jsdoc_last_change, $jsdoc_last_nid, $jsdoc_last_change, 0, $limit);
	328	while ($node = db_fetch_object($result)) {
	329	$node = node_load($node->nid);
	330	$type = 'jsdoc_' . jsdoc_get_version($node)->title;
	331
	332	$items = array($node);
	333	foreach (jsdoc_get_methods($node) as $method) {
	334	$method->title = "{$node->title}.{$method->name}";
	335	$items[] = $method;
	336	}
	337	foreach (jsdoc_get_properties($node) as $property) {
	338	$property->title = "{$node->title}.{$property->name}";
	339	$items[] = $property;
	340	}
	341	foreach ($items as $item) {
	342	$text = '<h1>'. implode(' ', _jsdoc_build_terms($item->title)) . '</h1> ' . jsdoc_get_teaser($item) . ' ' . jsdoc_get_body($item);
	343
	344	if (!($sid = db_result(db_query("SELECT sid FROM {jsdoc_variables} WHERE variable = '%s'", $item->title)))) {
	345	$sid = db_next_id('{jsdoc_variables}_sid');
	346	db_query("INSERT INTO {jsdoc_variables} (sid, variable, private) VALUES (%d, '%s', %d)", $sid, $item->title, jsdoc_is_private($item) \|\| jsdoc_has_private_parent($item));
	347	}
	348
	349	search_index($sid, $type, $text);
	350	}
	351
	352	$jsdoc_last_change = $node->changed;
	353	$jsdoc_last_nid = $node->nid;
	354	}
	355
	356	variable_set('jsdoc_cron_last', $jsdoc_last_change);
	357	variable_set('jsdoc_cron_last_nid', $jsdoc_last_nid);
	358	}
	359
	360	/**
	361	* Implementation of hook_search().
	362	*/
	363	function jsdoc_search($op = 'search', $keys = null) {
	364	switch ($op) {
	365	case 'name':
	366	return t('JavaScript Documentation');
	367	case 'search':
	368	// Get all projects
	369	// Get all versions marked 'HEAD' in each project
	370	$version = search_query_extract($keys, 'version');
	371	if (empty($version)) {
	372	$version = jsdoc_get_version()->title;
	373	}
	374	$keys = search_query_insert($keys, 'version');
	375
	376	$private = search_query_extract($keys, 'private');
	377	$keys = search_query_insert($keys, 'private');
	378
	379	$where = '1';
	380	if (!$private) {
	381	$where = "j.private = 0";
	382	}
	383
	384	$find = do_search(
	385	'(' . implode('), (', _jsdoc_build_terms($keys)) . ')',
	386	'jsdoc_' . $version,
	387	"INNER JOIN {jsdoc_variables} j ON (j.sid = i.sid)",
	388	$where,
	389	array(),
	390	'i.relevance + (15 / CHAR_LENGTH(j.variable)) AS score',
	391	"INNER JOIN {jsdoc_variables} j ON (j.sid = i.sid)"
	392	);
	393	$results = array();
	394	foreach ($find as $item) {
	395	$variable = db_result(db_query("SELECT variable FROM {jsdoc_variables} WHERE sid = %d", $item->sid));
	396	$actual = $node = jsdoc_object_node_load($variable, $version);
	397	if (!$node->nid) {
	398	$parts = explode('.', $variable);
	399	array_pop($parts);
	400	$node = jsdoc_object_node_load(implode('.', $parts), $version);
	401	$actual = _jsdoc_resolve_child($node, $variable);
	402	}
	403
	404	$info = jsdoc_node_info();
	405	$results[] = array(
	406	'url' => $actual->jsdoc_url,
	407	'link' => url($actual->jsdoc_url),
	408	'type' => "Version $version",
	409	'title' => $actual->title,
	410	'user' => '',
	411	'date' => '',
	412	'node' => $node,
	413	'score' => $item->score,
	414	'snippet' => (jsdoc_get_teaser($actual)) ? search_excerpt($keys, jsdoc_get_teaser($actual)) : ''
	415	);
	416	}
	417
	418	$term = trim(search_query_insert(search_query_insert($keys, 'private'), 'version'));
	419	if (count($results) == 1 && $results[0]['title'] == $term) {
	420	return drupal_goto($results[0]['url']);
	421	}
	422
	423	return $results;
	424	}
	425	}
	426
	427	/**
	428	* Implementation of hook_search_validate()
	429	*/
	430	function jsdoc_search_validate($form_id, $form_values, $form) {
	431	$keys = $form_values['processed_keys'];
	432
	433	$version = $form_values['jsdoc_version'];
	434	$keys = search_query_insert($keys, 'version', $version);
	435
	436	if ($form_values['jsdoc_private']) {
	437	$keys = search_query_insert($keys, 'private', 'true');
	438	}
	439	else {
	440	$keys = search_query_insert($keys, 'private');
	441	}
	442
	443	if (!empty($keys)) {
	444	form_set_value($form['basic']['inline']['processed_keys'], trim($keys));
	445	}
	446	}
	447
	448	/**
	449	* Implementation of hook_form_alter().
	450	*/
	451	function jsdoc_form_alter($form_id, &$form) {
	452	if ($form['type']['#value'] == 'jsdoc_object') {
	453	unset($form['taxonomy']);
	454	}
	455	elseif ($form_id == 'search_form' && $form['module']['#value'] == 'jsdoc') {
	456	foreach (jsdoc_get_versions() as $version) {
	457	$options[$version->title] = $version->title;
	458	}
	459
	460	if (empty($options)) {
	461	$options = array('' => '-----');
	462	}
	463
	464	$form['jsdoc_version'] = array(
	465	'#title' => t('Version'),
	466	'#type' => 'select',
	467	'#options' => $options,
	468	'#default_value' => jsdoc_get_version()->title
	469	);
	470
	471	if ($version = search_query_extract($form['basic']['inline']['keys']['#default_value'], 'version')) {
	472	$form['jsdoc_version']['#default_value'] = $version;
	473	}
	474
	475	$private = search_query_extract($form['basic']['inline']['keys']['#default_value'], 'private');
	476
	477	$form['jsdoc_private'] = array(
	478	'#title' => t('Include Private Variables'),
	479	'#type' => 'checkbox',
	480	'#default_value' => $private
	481	);
	482
	483	$form['#validate']['jsdoc_search_validate'] = array();
	484	}
	485	}
	486
	487	/**
	488	* Implementation of hook_help().
	489	*/
	490	function jsdoc_help($section = '') {
	491	$output = '';
	492
	493	switch ($section) {
	494	case 'admin/help#jsdoc':
	495	return '<p>' . t('View and edit JavaScript Documentation') . '</p>';
	496	case 'admin/modules#jsdoc':
	497	return t('View and edit JavaScript Documentation');
	498	case 'admin/settings/jsdoc/ignore':
	499	return t("
	500	<p>There will be several vocabularies created by this resource. Two of the more important are \"JavaScript Environments\" and \"JavaScript Conditions\". You should read their explanations below and make sure that these values exist in your vocabularies.</p>
	501	<p>In order for this to work, you need to declare both a file and two functions within that file. When the cron task runs, it will call a function that gets a list of files within your project. The files will be run one by one, each calling the second function. Our task expects an array to be returned in the following format:</p>
	502	<ul>
	503	<li><em>variable</em>: The name of the variable</li>
	504	<li><strong>Resource Specific</strong></li>
	505	<li><em>#requires</em>: The string literal '#requires'</li>
	506	<li><em>#provides</em>: The string literal '#provides'. It should match the requires statements of other files</li>
	507	<li><em>resource</em>: Your code might load different files depending on different conditions. A resource is a string to indicate the location of a file</li>
	508	<li><em>environment</em>: An indicator of where your code is running. Only one is available during run-time. Must correspond to the entry in \"JavaScript Environments\"</li>
	509	<li><em>condition</em>: An indicator of a condition under which your code is running. Multiple conditions are available at run-time. Must correspond to an entry in \"JavaScript Conditions\"</li>
	510	<li><strong>Object Specific</strong></li>
	511	<li><em>private</em>: True if this object isn't meant to be public</li>
	512	<li><em>type</em>: Object type. If it's a function, set to 'Function'</li>
	513	<li><em>summary</em>: A short description of what the item does.</li>
	514	<li><em>description</em>: An extended description of what the item does.</li>
	515	<li><strong>Function Specific</strong></li>
	516	<li><em>aliases</em>: The name of a function/variable this references. In code, it would have been fn1 = fn2, where fn1 aliases fn2</li>
	517	<li><em>instance</em>: The name of a function that the 'this' variable refers to. Useful if a function is declared in a constructor.</li>
	518	<li><em>initialized</em>: True if this variable references an initialized function.</li>
	519	<li><em>classlike</em>: True if a function acts like a class.</li>
	520	<li><em>prototype</em>: This object is attached via the prototype of this function</li>
	521	<li><em>returns</em>: Object type of the function return.</li>
	522	<li><em>return summary</em>: Summary of the function return.</li>
	523	<li><em>chains</em>: The string literal 'chains'</li>
	524	<li><em>chain-type</em>: call, or prototype. Basically, either doing this.call(parent); or this.prototype = new parent; respectively</li>
	525	<li><em>function</em>: A function name</li>
	526	<li><em>parameters</em>: The string literal 'parameters'</li>
	527	<li><em>parameter</em>: The name of the parameter</li>
	528	<li><em>optional</v>: True if the parameter is documented as optional</li>
	529	<li><em>repeating</em>: True if the parameter is documented as repeating</li>
	530	<li><em>type</em>: Object type of the parameter.</li>
	531	<li><em>source</em>: Source Code (if it's a function)</li>
	532	</ul>
	533	<pre>array(
	534	'variable' => array(
	535	'#requires' => array(
	536	array('environment/condition', 'resource')
	537	)
	538	'type' => '',
	539	'source' => '',
	540	'summary' => '',
	541	'description' => '',
	542	'aliases' => '',
	543	'instance' => '',
	544	'initialized' => boolean,
	545	'prototype' => '',
	546	'returns' => '',
	547	'return_summary' => '',
	548	'chains' => array(
	549	array('chain-type', 'function')
	550	),
	551	'parameters' => array(
	552	'parameter' => array(
	553	'optional' => boolean,
	554	'repeating' => boolean,
	555	'type' => '',
	556	'summary' => ''
	557	)
	558	)
	559	)
	560	)</pre>");
	561	}
	562
	563	return '';
	564	}
	565
	566	// Views
	567	// =====
	568
	569	function jsdoc_doc_form(&$node) {
	570	$form = array(
	571	'#attributes' => array(
	572	'enctype' => 'multipart/form-data'
	573	)
	574	);
	575
	576	$form['title'] = array(
	577	'#type' => 'textfield',
	578	'#title' => t('Version Number'),
	579	'#default_value' => $node->title
	580	);
	581
	582	$form['counts'] = array(
	583	'#type' => 'item',
	584	'#title' => t('Objects'),
	585	'#value' => ($node->nid ? db_result(db_query("SELECT COUNT(*) FROM {jsdoc_objects} WHERE did = %d", $node->nid)) : 0)
	586	);
	587
	588	$form['upload'] = array(
	589	'#title' => t('Documentation File'),
	590	'#type' => 'file'
	591	);
	592
	593	$form['download'] = array(
	594	'#title' => t('Documentation URL'),
	595	'#type' => 'textfield'
	596	);
	597
	598	return $form;
	599	}
	600
	601	function jsdoc_doc_view($node, $teaser = FALSE, $page = FALSE) {
	602	$node->content['counts'] = array(
	603	'#type' => 'item',
	604	'#title' => t('Objects'),
	605	'#value' => db_result(db_query("SELECT COUNT(*) FROM {jsdoc_objects} WHERE did = %d", $node->nid))
	606	);
	607
	608	return $node;
	609	}
	610
	611	function jsdoc_doc_update($node) {
	612	jsdoc_doc_insert($node);
	613	}
	614
	615	function jsdoc_doc_insert($node) {
	616	$start = time();
	617	if ($file = file_check_upload()) {
	618	$doc = fopen($file->filepath, 'r');
	619	}
	620	elseif ($node->download) {
	621	$doc = fopen($node->download, 'r');
	622	}
	623	else {
	624	return;
	625	}
	626
	627	$buffer = array();
	628	while (!feof($doc)) {
	629	set_time_limit(30);
	630
	631	$line = stream_get_line($doc, 9999, "\n");
	632	if (preg_match('%^\t"([^"]+)": \{%', $line, $match)) {
	633	$id = $match[1];
	634	$in = true;
	635	}
	636	elseif (preg_match('%^\t\}%', $line, $match)) {
	637	$in = false;
	638	$json = json_decode('{' . implode("\n", $buffer) . '}');
	639
	640	if ($nid = db_result(db_query("SELECT n.nid FROM {node} AS n INNER JOIN {jsdoc_objects} j ON (j.nid = n.nid) WHERE BINARY n.title = '%s' AND j.did = %d", $id, $node->nid))) {
	641	$object = node_load($nid);
	642	$object->json = $json;
	643	}
	644	else {
	645	$object = (object)array(
	646	'title' => $id,
	647	'type' => 'jsdoc_object',
	648	'version' => $node,
	649	'json' => $json
	650	);
	651	}
	652
	653	node_save($object);
	654	node_load($object->nid, NULL, TRUE);
	655	$buffer = array();
	656	}
	657	elseif($in) {
	658	$buffer[] = $line;
	659	}
	660	}
	661
	662	// cache_set("jsdoc_namespaces_{$version->title}
	663
	664	$query = db_query("DELETE FROM {cache} WHERE cid LIKE 'jsdoc_namespaces_%s:%%'", $node->title);
	665
	666	$query = db_query("SELECT n.nid FROM {node} AS n INNER JOIN {jsdoc_objects} AS j ON (j.nid = n.nid) WHERE type = 'jsdoc_object' AND j.did = %d AND changed < %d", $node->nid, $start);
	667	while ($nid = db_fetch_object($query)) {
	668	set_time_limit(30);
	669	node_delete($nid->nid);
	670	}
	671	}
	672
	673	function jsdoc_doc_delete(&$node) {
	674	$query = db_query("SELECT nid FROM {jsdoc_objects} WHERE did = %d", $node->nid);
	675	while ($nid = db_fetch_object($query)) {
	676	set_time_limit(30);
	677	node_delete($nid->nid);
	678	}
	679	}
	680
	681	// Implemented node-type hook functions
	682	// ====================================
	683
	684	/**
	685	* Implementation of hook_access().
	686	*/
	687	function jsdoc_object_access($op, $node) {
	688	if ($op == 'update') {
	689	return user_access('edit jsdoc');
	690	}
	691	elseif ($op == 'view') {
	692	return user_access('access content');
	693	}
	694
	695	return false;
	696	}
	697
	698	/**
	699	* Implementation of hook_insert().
	700	*/
	701	function jsdoc_object_insert($node) {
	702	db_query("INSERT INTO {jsdoc_objects} (nid, did, json) VALUES (%d, %d, '%s')", $node->nid, $node->version->nid, serialize($node->json));
	703	}
	704
	705	/**
	706	* Implementation of hook_update().
	707	*/
	708	function jsdoc_object_update($node) {
	709	db_query("UPDATE {jsdoc_objects} SET json = '%s' WHERE nid = %d", serialize($node->json), $node->nid);
	710	}
	711
	712	/**
	713	* Implementation of hook_delete
	714	*/
	715	function jsdoc_object_delete(&$node) {
	716	$type = 'jsdoc_' . $node->title;
	717	$query = db_query("SELECT sid FROM {jsdoc_variables} WHERE variable = '%s'", $node->title);
	718	if ($sid = db_fetch_object($query)) {
	719	search_wipe($sid->sid, $type);
	720	}
	721	db_query("DELETE FROM {jsdoc_objects} WHERE nid = %d", $node->nid);
	722	}
	723
	724	function _jsdoc_convert_object(&$node, $object, $parent = FALSE, $method = FALSE) {
	725	$node->teaser = $object->summary;
	726	$node->body = $object->description;
	727
	728	if (!$node->title && $object->name) {
	729	$node->title = $object->name;
	730	}
	731
	732	if (!$node->jsdoc_version) {
	733	$node->jsdoc_version = $parent->jsdoc_version;
	734	}
	735
	736	if ($method) {
	737	$node->jsdoc_raw_type = 'Function';
	738	}
	739	else {
	740	$node->jsdoc_raw_type = $object->type ? $object->type : 'Object';
	741	}
	742
	743	$node->jsdoc_classlike = $object->classlike;
	744
	745	$node->jsdoc_formatted = _jsdoc_format_type($node->jsdoc_raw_type, $node->jsdoc_classlike);
	746
	747	$returndescription = 'return-description';
	748	$node->jsdoc_return_summary = $object->$returndescription;
	749
	750	$returntypes = 'return-types';
	751	$node->jsdoc_return_types = $object->$returntypes;
	752
	753	$node->jsdoc_examples = $object->examples;
	754
	755	$node->jsdoc_resources = $object->resources;
	756
	757	$node->jsdoc_provides = $object->provides;
	758
	759	$node->jsdoc_superclass = $object->superclass;
	760
	761	$node->jsdoc_mixins = $object->mixins;
	762
	763	if (!empty($object->tags)) {
	764	$node->jsdoc_tags = array();
	765	foreach (explode(' ', $object->tags) as $tag) {
	766	$node->jsdoc_tags[$tag] = TRUE;
	767	}
	768	}
	769
	770	$node->jsdoc_private = $object->private;
	771
	772	$node->jsdoc_protected = $object->protected;
	773
	774	$node->jsdoc_deprecated = $object->deprecated;
	775
	776	$node->jsdoc_private_parent = $object->privateparent;
	777
	778	$node->jsdoc_scope = $object->scope ? $object->scope : 'normal';
	779
	780	if ($node->jsdoc_raw_type == 'Function') {
	781	if (!$node->jsdoc_classlike) {
	782	$parameters = $object->parameters;
	783	}
	784	else {
	785	if (is_array($object->methods)) {
	786	$constructors = array();
	787	foreach ($object->methods as $method) {
	788	if ($method->constructor) {
	789	$constructors[$method->constructor] = $method;
	790	}
	791	}
	792	foreach (array('constructor', 'preamble', 'postscript') as $constructor) {
	793	if ($method = $constructors[$constructor]) {
	794	$node->jsdoc_constructor = $method;
	795	if (!empty($method->parameters)) {
	796	$parameters = $method->parameters;
	797	break;
	798	}
	799	}
	800	}
	801	if (!$node->jsdoc_constructor && !empty($constructors)) {
	802	$node->jsdoc_constructor = reset($constructors);
	803	}
	804	}
	805	}
	806
	807	$node->jsdoc_parameters = $parameters;
	808	}
	809
	810	if (!empty($object->methods)) {
	811	foreach ($object->methods as $method) {
	812	if (!$method->constructor) {
	813	$method->jsdoc_url = 'jsdoc/' . jsdoc_get_version($node)->title . '/' . $node->title . '.' . $method->name;
	814	$node->jsdoc_methods[] = $method;
	815	}
	816	}
	817	}
	818
	819	if (!empty($object->properties)) {
	820	foreach ($object->properties as $property) {
	821	$property->jsdoc_url = 'jsdoc/' . jsdoc_get_version($node)->title . '/' . $node->title . '.' . $property->name;
	822	$node->jsdoc_properties[] = $property;
	823	}
	824	}
	825
	826	if ($object->jsdoc_url) {
	827	$node->jsdoc_url = $object->jsdoc_url;
	828	}
	829	else {
	830	$node->jsdoc_url = 'jsdoc/' . jsdoc_get_version($node)->title . '/' . $node->title;
	831	}
	832
	833	unset($node->json);
	834
	835	return $node;
	836	}
	837
	838	/**
	839	* Implementation of hook_load().
	840	*/
	841	function jsdoc_object_load($node, $method = FALSE) {
	842	// TODO: Deal with alias
	843	_jsdoc_init();
	844
	845	$additions = db_fetch_object(db_query("SELECT json, did FROM {jsdoc_objects} WHERE nid = %d", $node->nid));
	846	$additions->title = $node->title;
	847	$additions->json = unserialize($additions->json);
	848	$node->jsdoc_version = $additions->jsdoc_version = node_load($additions->did);
	849
	850	_jsdoc_convert_object($additions, $additions->json, $node, $method);
	851
	852	return $additions;
	853	}
	854
	855	/**
	856	* Implementation of hook_view().
	857	*/
	858	function jsdoc_object_view($node, $teaser = false, $page = false) {
	859	$node->teaser = '';
	860	$node->body = '';
	861	if (!$teaser) {
	862	$node->body = l($node->title, $node->jsdoc_url);
	863	}
	864	$node->title = t('Object');
	865	$node->taxonomy = array();
	866	$node = node_prepare($node, $teaser);
	867	return $node;
	868	}
	869
	870	/**
	871	* Path: admin/settings/jsdoc
	872	*/
	873	function jsdoc_admin() {
	874	$form = array();
	875
	876	$formats = filter_formats();
	877	$options = array();
	878	foreach ($formats as $format) {
	879	$options[$format->format] = $format->name;
	880	}
	881
	882	$form['jsdoc_input_format'] = array(
	883	'#title' => t('Default Input Format'),
	884	'#type' => 'radios',
	885	'#options' => $options,
	886	'#required' => true,
	887	'#default_value' => variable_get('jsdoc_input_format', 1)
	888	);
	889
	890	return system_settings_form($form);
	891	}
	892
	893	function jsdoc_get_version(&$node = FALSE) {
	894	if (!$node) {
	895	foreach (jsdoc_get_versions() as $version) {
	896	if ($version->title != 'HEAD') {
	897	return $version;
	898	}
	899	}
	900	}
	901	return $node->jsdoc_version;
	902	}
	903
	904	function jsdoc_get_versions($node = FALSE, $title = NULL) {
	905	static $cache = array();
	906	$versions = array();
	907
	908	if ($node) {
	909	if ($node->title) {
	910	$cache_key = $node->title;
	911	if ($cache[$cache_key]) {
	912	return $cache[$cache_key];
	913	}
	914	}
	915	$with_json = ($title) ? ', j.json' : '';
	916	$query = db_query("SELECT j.did AS nid $with_json FROM {jsdoc_objects} j INNER JOIN {node} n ON (n.nid = j.nid) WHERE n.title = '%s' GROUP BY j.did", $node->title);
	917	}
	918	else {
	919	$cache_key = '%ALL%';
	920	if (isset($cache[$cache_key])) {
	921	return $cache[$cache_key];
	922	}
	923	$query = db_query("SELECT nid FROM {node} WHERE type = 'jsdoc_doc' ORDER BY nid DESC");
	924	}
	925
	926	while ($version = db_fetch_object($query)) {
	927	if ($version->json && $node->title != $title) {
	928	$parts = explode('.', $title);
	929	if (count($parts) > 1) {
	930	$last = array_pop($parts);
	931	$parent = implode('.', $parts);
	932	$found = FALSE;
	933	$json = unserialize($version->json);
	934	$properties = array();
	935	if ($json->methods) {
	936	$properties = array_merge($properties, $json->methods);
	937	}
	938	if ($json->properties) {
	939	$properties = array_merge($properties, $json->properties);
	940	}
	941	foreach ($properties as $property) {
	942	if ($property->scope == 'normal' && $property->name == $title) {
	943	$found = TRUE;
	944	break;
	945	}
	946	elseif ($property->name == $last) {
	947	$found = TRUE;
	948	break;
	949	}
	950	}
	951	if (!$found) {
	952	continue;
	953	}
	954	}
	955	}
	956	$versions[] = node_load($version->nid);
	957	}
	958
	959	if ($cache_key) {
	960	$cache[$cache_key] = $versions;
	961	}
	962
	963	return $versions;
	964	}
	965
	966	function jsdoc_get_return_summary(&$node) {
	967	if (isset($node->jsdoc_return_summary_formatted)) {
	968	return $node->jsdoc_return_summary_formatted;
	969	}
	970
	971	return ($node->jsdoc_return_summary_formatted = trim(preg_replace('%(^<p>\|</p>$)%', '', str_replace("\n", ' ', $object->jsdoc_return_summary))));
	972	}
	973
	974	function jsdoc_get_return_types(&$node) {
	975	if (empty($node->jsdoc_return_types)) {
	976	return array();
	977	}
	978	return $node->jsdoc_return_types;
	979	}
	980
	981	function jsdoc_get_parameters(&$node) {
	982	if (isset($node->jsdoc_formatted_parameters)) {
	983	return $node->jsdoc_formatted_parameters;
	984	}
	985
	986	if (empty($node->jsdoc_parameters)) {
	987	$node->jsdoc_parameters = array();
	988	}
	989
	990	foreach ($node->jsdoc_parameters as $i => $parameter) {
	991	$node->jsdoc_parameters[$i]->jsdoc_formatted = _jsdoc_format_type($parameter->type, false, $parameter->usage == 'optional', $parameter->usage == 'repeating' \|\| $parameter->usage == 'one-or-more');
	992	}
	993
	994	return ($node->jsdoc_formatted_parameters = $node->jsdoc_parameters);
	995	}
	996
	997	function jsdoc_get_examples(&$node, $markedup=false) {
	998	if (empty($node->jsdoc_examples)) {
	999	return array();
	1000	}
	1001	if (isset($node->jsdoc_formatted_examples)) {
	1002	return $node->jsdoc_formatted_examples;
	1003	}
	1004
	1005	$examples = array();
	1006	foreach ($node->jsdoc_examples as $example) {
	1007	$examples[] = _jsdoc_markup_text($example, jsdoc_get_version($node), $node->title);
	1008	}
	1009
	1010	return ($node->jsdoc_formatted_examples = $examples);
	1011	}
	1012
	1013	function jsdoc_get_parent_prototype(&$node) {
	1014	if ($node->jsdoc_superclass) {
	1015	return jsdoc_object_node_load($node->jsdoc_superclass, jsdoc_get_version($node));
	1016	}
	1017	}
	1018
	1019	function jsdoc_is_initialized(&$node) {
	1020	return false;
	1021	}
	1022
	1023	function jsdoc_get_tags(&$node) {
	1024	if (empty($node->jsdoc_tags)) {
	1025	return array();
	1026	}
	1027	return $node->jsdoc_tags;
	1028	}
	1029
	1030	function jsdoc_is_classlike(&$node) {
	1031	return $node->jsdoc_classlike;
	1032	}
	1033
	1034	function jsdoc_get_teaser(&$node) {
	1035	if (isset($node->formatted_teaser)) {
	1036	return $node->formatted_teaser;
	1037	}
	1038
	1039	return ($node->formatted_teaser = $node->teaser);
	1040	}
	1041
	1042	function jsdoc_get_body(&$node) {
	1043	$version = jsdoc_get_version($node)->title;
	1044	$body = trim($node->body);
	1045	$variables = _jsdoc_get_variables();
	1046	foreach (array_unique(preg_split('%\s+%', strip_tags($body))) as $variable) {
	1047	if ($variables[$variable] && $variable != $node->title) {
	1048	$body = str_replace($variable, l($variable, 'jsdoc/' . $version . '/' . $variable), $body);
	1049	}
	1050	}
	1051	return $body;
	1052	}
	1053
	1054	function jsdoc_is_function(&$node) {
	1055	return (jsdoc_get_type($node) == 'Function' \|\| jsdoc_get_type($node) == 'Constructor');
	1056	}
	1057
	1058	function jsdoc_is_private(&$node) {
	1059	return $node->jsdoc_private;
	1060	}
	1061
	1062	function jsdoc_is_protected(&$node) {
	1063	return $node->jsdoc_protected;
	1064	}
	1065
	1066	function jsdoc_is_deprecated(&$node) {
	1067	return $node->jsdoc_deprecated;
	1068	}
	1069
	1070	function jsdoc_has_private_parent(&$node) {
	1071	foreach (jsdoc_get_namespace_parents($node) as $parent) {
	1072	if ($parent->jsdoc_private) {
	1073	return true;
	1074	}
	1075	}
	1076
	1077	return $node->jsdoc_private_parent;
	1078	}
	1079
	1080	function jsdoc_get_type(&$node) {
	1081	if (isset($node->jsdoc_type)) {
	1082	return $node->jsdoc_type;
	1083	}
	1084
	1085	if (is_object($node->type)) {
	1086	$type = $node->type->title;
	1087	}
	1088	else {
	1089	$type = $node->jsdoc_raw_type;
	1090	unset($node->jsdoc_raw_type);
	1091	}
	1092
	1093	if ($type == 'Function') {
	1094	if (jsdoc_is_classlike($node)) {
	1095	$type = 'Constructor';
	1096	}
	1097	elseif (count(jsdoc_get_child_instances($node, true)) \|\| count(jsdoc_get_child_prototypes($node, true))) {
	1098	$type = 'Constructor';
	1099	}
	1100	}
	1101
	1102	return ($node->jsdoc_type = $type);
	1103	}
	1104
	1105	function jsdoc_get_resource(&$node) {
	1106	if (count($node->jsdoc_resources) == 1) {
	1107	return $node->jsdoc_resources[0];
	1108	}
	1109	}
	1110
	1111	function jsdoc_get_source($node, $resolve=false, $depth=0) {
	1112	return '';
	1113	}
	1114
	1115	function jsdoc_get_provide(&$node) {
	1116	if (count($node->jsdoc_provides) == 1) {
	1117	return $node->jsdoc_provides[0];
	1118	}
	1119	}
	1120
	1121	function jsdoc_get_mixins(&$node, $type = NULL) {
	1122	if (empty($node->jsdoc_mixins)) {
	1123	return array();
	1124	}
	1125	if (isset($node->jsdoc_resolved_mixins)) {
	1126	return $type ? $node->jsdoc_resolved_mixins[$type] : $node->jsdoc_resolved_mixins;
	1127	}
	1128
	1129	$version = jsdoc_get_version($node);
	1130	$resolved_mixins = array('prototype' => array(), 'instance' => array(), 'normal' => array());
	1131	foreach ($node->jsdoc_mixins as $from => $mixins) {
	1132	foreach ($mixins as $mixin) {
	1133	$location = $mixin->location;
	1134	if (substr($location, -10) == '.prototype') {
	1135	$location = substr($location, 0, -10);
	1136	}
	1137	$mixin_node = jsdoc_object_node_load($location, $version);
	1138	if ($mixin_node->nid) {
	1139	$resolved_mixins[$from][] = (object)array(
	1140	'attached' => $node,
	1141	'scope' => $mixin->scope,
	1142	'node' => $mixin_node
	1143	);
	1144	}
	1145	}
	1146	}
	1147
	1148	$node->jsdoc_resolved_mixins = $resolved_mixins;
	1149
	1150	return jsdoc_get_mixins($node, $type);
	1151	}
	1152
	1153	function _jsdoc_get_attributes($attribute, &$node, $is_method, $scope) {
	1154	$attribute = 'jsdoc_' . $attribute;
	1155
	1156	$items = array();
	1157	if (!empty($node->$attribute)) {
	1158	foreach ($node->$attribute as $item){
	1159	$converted = (object)array(
	1160	'title' => "{$node->title}.{$item->name}",
	1161	'name' => $item->name
	1162	);
	1163	if ($scope) {
	1164	$scopes = explode('-', $item->scope);
	1165	if (in_array($scope, $scopes)) {
	1166	$items[] = _jsdoc_convert_object($converted, $item, $node, $is_method);
	1167	}
	1168	}
	1169	else {
	1170	$items[] = _jsdoc_convert_object($converted, $item, $node, $is_method);
	1171	}
	1172	}
	1173	}
	1174
	1175	if (!$scope \|\| $scope == 'normal') {
	1176	$query = db_query("SELECT n.nid, n.title FROM {node} AS n INNER JOIN {jsdoc_objects} AS j ON (j.nid = n.nid) WHERE n.title LIKE '%s.%%' AND j.did = %d", $node->title, jsdoc_get_version($node)->nid);
	1177	while ($result = db_fetch_object($query)) {
	1178	$parts = explode('.', $result->title);
	1179	$name = array_pop($parts);
	1180	if (implode('.', $parts) == $node->title) {
	1181	$item = node_load($result->nid);
	1182	$item->name = $name;
	1183	if ($is_method) {
	1184	if ($item->jdsoc_raw_type == 'Function') {
	1185	$items[] = $item;
	1186	}
	1187	}
	1188	else {
	1189	$items[] = $item;
	1190	}
	1191	}
	1192	}
	1193	}
	1194
	1195	return $items;
	1196	}
	1197
	1198	function jsdoc_get_methods(&$node, $scope = NULL) {
	1199	return _jsdoc_get_attributes('methods', $node, TRUE, $scope);
	1200	}
	1201
	1202	function jsdoc_get_properties(&$node, $scope = NULL) {
	1203	return _jsdoc_get_attributes('properties', $node, FALSE, $scope);
	1204	}
	1205
	1206	function jsdoc_get_child_instances() {
	1207	return array();
	1208	}
	1209
	1210	function jsdoc_get_child_prototypes() {
	1211	return array();
	1212	}
	1213
	1214	function jsdoc_is_namespace(&$node) {
	1215	return !!$node->nid && $node->jsdoc_raw_type != 'Function';
	1216	}
	1217
	1218
	1219	// Node Load Functions
	1220	// ===================
	1221
	1222	/**
	1223	* Custom version of node_load for versions
	1224	*/
	1225	function jsdoc_version_node_load($version_name) {
	1226	return node_load(array(
	1227	'type' => 'jsdoc_doc',
	1228	'title' => $version_name
	1229	));
	1230	}
	1231
	1232	function jsdoc_object_node_load($name, $version=false, $exact=true, $broad=false) {
	1233	$nodes = jsdoc_object_nodes_load($name, $version, $exact, $broad);
	1234	if (count($nodes) == 1) {
	1235	return $nodes[0];
	1236	}
	1237	elseif (!empty($nodes)) {
	1238	$version = jsdoc_get_version();
	1239	foreach($nodes as $match) {
	1240	if ($match->version->nid == $version->nid) {
	1241	return $match;
	1242	}
	1243	}
	1244	}
	1245	return (object)array();
	1246	}
	1247
	1248	/**
	1249	* Custom version of node_load for objects
	1250	*/
	1251	function jsdoc_object_nodes_load($name, $version=false, $exact=true, $broad=false) {
	1252	static $cache = array();
	1253
	1254	$lower_name = strtolower($name);
	1255
	1256	$override_name = false;
	1257	$name_override = $name;
	1258
	1259	if ($lower_name == 'bool') {
	1260	$name = 'Boolean';
	1261	}
	1262	elseif ($lower_name == 'int' \|\| $lower_name == 'integer') {
	1263	$override_name = true;
	1264	$name_override = 'Integer';
	1265	$name = 'Number';
	1266	}
	1267	elseif ($lower_name == 'float' \|\| $lower_name == 'decimal') {
	1268	$override_name = true;
	1269	$name_override = ucfirst($lower_name);
	1270	$name = 'Number';
	1271	}
	1272
	1273	$global_vars = array('Array', 'Boolean', 'Date', 'Error', 'Function', 'Number', 'Object', 'RegExp', 'String');
	1274	$lower_global_vars = array('array', 'boolean', 'date', 'error', 'function', 'number', 'object', 'regexp', 'string');
	1275	if (($pos = array_search($lower_name, $lower_global_vars)) !== false) {
	1276	$name = $global_vars[$pos];
	1277	}
	1278
	1279	if (in_array($name, $global_vars)) {
	1280	return array((object)array(
	1281	'title' => ($override_name) ? $name_override : $name,
	1282	'jsdoc_url' => 'http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:' . $name
	1283	));
	1284	}
	1285	elseif ($lower_name == 'window') {
	1286	return array((object)array(
	1287	'title' => $name,
	1288	'jsdoc_url' => 'http://developer.mozilla.org/en/docs/DOM:window'
	1289	));
	1290	}
	1291	elseif ($lower_name == 'documentelement' \|\| $lower_name == 'document') {
	1292	return array((object)array(
	1293	'title' => $name,
	1294	'jsdoc_url' => 'http://developer.mozilla.org/en/docs/DOM:document'
	1295	));
	1296	}
	1297	elseif (in_array($lower_name, array('node', 'htmlelment', 'domnode'))) {
	1298	return array((object)array(
	1299	'title' => $name,
	1300	'jsdoc_url' => 'http://developer.mozilla.org/en/docs/DOM:element'
	1301	));
	1302	}
	1303	elseif ($name == 'Constructor') {
	1304	return array((object)array(
	1305	'title' => $name,
	1306	'jsdoc_url' => 'http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Guide:Class-Based_vs._Prototype-Based_Languages#Defining_a_Class'
	1307	));
	1308	}
	1309
	1310	// Resolve the version the best that we can
	1311	if (is_object($version) && $version->nid) {
	1312	$version_nid = $version->nid;
	1313	}
	1314	elseif (is_string($version)) {
	1315	$version_nid = jsdoc_version_node_load($version)->nid;
	1316	}
	1317	elseif (is_numeric($version)) {
	1318	$version_nid = $version;
	1319	}
	1320
	1321	if ($version_nid && (!is_object($version) \|\| !$version->nid)) {
	1322	$version = node_load($version_nid);
	1323	}
	1324
	1325	if ($name) {
	1326	$cache_key = sprintf('%s,%s,%s,%s', $name, $version_nid, $exact, $broad);
	1327	if (isset($cache[$cache_key])) {
	1328	$nodes = array();
	1329	foreach ($cache[$cache_key] as $nid) {
	1330	$nodes[] = node_load($nid);
	1331	}
	1332	if (empty($nodes)) {
	1333	if ($broad) {
	1334	return array((object)array(
	1335	'title' => $name
	1336	));
	1337	}
	1338	else {
	1339	return array();
	1340	}
	1341	}
	1342	return $nodes;
	1343	}
	1344
	1345	// We have a few situations:
	1346	// name
	1347	// project, name
	1348	// project, version, name
	1349	// project, version, resource, name
	1350
	1351	// If we're missing the version, assume the latest release
	1352	// If we're missing the project, look up stuff by name
	1353
	1354	$binary = ($exact) ? 'BINARY' : '';
	1355	$title_check = ($exact) ? "= '%s'" : "LIKE '%%%s%%'";
	1356	$nodes = array();
	1357	$results = array();
	1358
	1359	if ($version_nid) {
	1360	$query = db_query("SELECT n.nid FROM {node} n INNER JOIN {jsdoc_objects} j ON (j.nid = n.nid) WHERE n.title $title_check AND $binary n.title $title_check AND j.did = %d", $name, $name, $version_nid);
	1361	}
	1362	else {
	1363	$version_nids = array(-1);
	1364	foreach (jsdoc_get_versions() as $version) {
	1365	$version_nids[] = $version->nid;
	1366	}
	1367	$query = db_query("SELECT n.nid, j.did, version.title AS version FROM {node} n INNER JOIN {jsdoc_objects} j ON (j.nid = n.nid) INNER JOIN {node} version ON (version.nid = j.did) WHERE n.title $title_check AND $binary n.title $title_check AND j.did IN (%s) ORDER BY version.created DESC", $name, $name, implode(',', $version_nids));
	1368	}
	1369
	1370	while ($result = db_fetch_object($query)) {
	1371	if ($result->version) {
	1372	if ($result->version != 'HEAD') {
	1373	$nodes[] = node_load($result->nid);
	1374	break;
	1375	}
	1376	}
	1377	else {
	1378	$nodes[] = node_load($result->nid);
	1379	}
	1380	}
	1381
	1382	$cache[$cache_key] = array_map('_jsdoc_extract_nids', $nodes);
	1383	}
	1384
	1385	if (empty($nodes)) {
	1386	if ($broad) {
	1387	return array((object)array(
	1388	'title' => $name
	1389	));
	1390	}
	1391	else {
	1392	return array();
	1393	}
	1394	}
	1395
	1396	return $nodes;
	1397	}
	1398
	1399	function _jsdoc_extract_nids($node) {
	1400	return $node->nid;
	1401	}
	1402
	1403	function jsdoc_parameter_weight_sort($a, $b){
	1404	return ($a['weight'] == $b['weight']) ? 0 : ($a['weight'] < $b['weight']) ? -1 : 1;
	1405	}
	1406
	1407	/**
	1408	* Path: jsdoc/404
	1409	*/
	1410	function jsdoc_404() {
	1411	$args = explode('/', $_REQUEST['destination']);
	1412	if (count($args) == 1 && $args[0] != 'jsdoc') {
	1413	global $_menu;
	1414	unset($_menu['items']);
	1415	menu_set_active_item('jsdoc/' . $args[0]);
	1416	print theme('page', menu_execute_active_handler());
	1417	exit();
	1418	}
	1419
	1420	return '<p>' . t('The page you requested was not found.') . '</p>';
	1421	}
	1422
	1423	/**
	1424	* Path: jsdoc/feedback
	1425	*/
	1426	function jsdoc_feedback() {
	1427	$count = 0;
	1428	if ($_POST['page'] && $_POST['feedback']) {
	1429	$feedback = array();
	1430	if ($cached = cache_get('jsdoc_feedback')) {
	1431	$feedback = unserialize($cached->data);
	1432	}
	1433
	1434	if (!isset($feedback[$_POST['page']][$_POST['feedback']])) {
	1435	$feedback[$_POST['page']][$_POST['feedback']] = 0;
	1436	}
	1437
	1438	$count = ++$feedback[$_POST['page']][$_POST['feedback']];
	1439
	1440	cache_set('jsdoc_feedback', 'cache', serialize($feedback));
	1441	}
	1442
	1443	print $count;
	1444	}
	1445
	1446	function jsdoc_feedback_review() {
	1447	drupal_set_title(t('Feedback Review'));
	1448
	1449	$feedback = array();
	1450	if ($cached = cache_get('jsdoc_feedback')) {
	1451	$feedback = unserialize($cached->data);
	1452	}
	1453
	1454	$by_count = array();
	1455	foreach ($feedback as $page => $stats) {
	1456	$total = 0;
	1457	foreach ($stats as $type => $count) {
	1458	$total += $count;
	1459	}
	1460	$by_count[$total][] = array(
	1461	'page' => $page,
	1462	'feedback' => $stats
	1463	);
	1464	}
	1465
	1466	krsort($by_count);
	1467
	1468	$output = '<ul>';
	1469	foreach ($by_count as $pages) {
	1470	foreach ($pages as $page) {
	1471	$output .= '<li>' . l($page['page'], sprintf('jsdoc/%s', $page['page'])) . '<ul>';
	1472	foreach ($page['feedback'] as $type => $count) {
	1473	$output .= '<li>' . $type . ': ' . $count . '</li>';
	1474	}
	1475	$output .= '</ul></li>';
	1476	}
	1477	}
	1478	$output .= '</ul>';
	1479
	1480	return $output;
	1481	}
	1482
	1483	/**
	1484	* Path: jsdoc/jsonp
	1485	*/
	1486	function jsdoc_jsonp($batch=false, $json=false) {
	1487	$recursion = false;
	1488	if ($json) {
	1489	$recursion = true;
	1490	$_JSON = $json;
	1491	}
	1492	else {
	1493	$_JSON = array();
	1494	foreach (explode('&', getenv('QUERY_STRING')) as $query_string) {
	1495	list($key, $value) = explode('=', $query_string, 2);
	1496	$value = urldecode($value);
	1497	if (isset($_JSON[$key])) {
	1498	if (!is_array($_JSON[$key])) {
	1499	$_JSON[$key] = array($_JSON[$key]);
	1500	}
	1501	$_JSON[$key][] = $value;
	1502	}
	1503	else {
	1504	$_JSON[$key] = $value;
	1505	}
	1506	}
	1507	}
	1508
	1509	$names = array();
	1510	if ($batch) {
	1511	$names = (is_array($_JSON['names'])) ? $_JSON['names'] : array($_JSON['names']);
	1512	}
	1513	else {
	1514	$names = array($_JSON['name']);
	1515	}
	1516
	1517	$attributes = ($_JSON['attributes']) ? $_JSON['attributes'] : array('summary', 'type', 'returns', 'parameters');
	1518	if (!is_array($attributes)) {
	1519	$attributes = array($attributes);
	1520	}
	1521
	1522	foreach ($names as $name) {
	1523	if (empty($name)) {
	1524	continue;
	1525	}
	1526	if ($_JSON['exact']) {
	1527	if ($nodes = jsdoc_object_node_load($name, $_JSON['version'], true)){
	1528	$nodes = array($nodes);
	1529	}
	1530	}
	1531	else {
	1532	$nodes = jsdoc_object_nodes_load($name, $_JSON['version'], false);
	1533	}
	1534	foreach ($nodes as $node) {
	1535	$formatted = (object)array('name' => $name);
	1536	foreach ($attributes as $attribute) {
	1537	switch ($attribute) {
	1538	case 'summary':
	1539	$formatted->summary = jsdoc_get_teaser($node);
	1540	break;
	1541	case 'type':
	1542	$formatted->type = jsdoc_get_type($node);
	1543	break;
	1544	case 'returns':
	1545	$formatted->returns = array(
	1546	'types' => array(),
	1547	'summary' => jsdoc_get_return_summary($node)
	1548	);
	1549	foreach (jsdoc_get_return_types($node) as $type) {
	1550	$themed = _jsdoc_get_type_themed($type->type, $node, true);
	1551	if ($themed) {
	1552	$formatted->returns['types'][] = $themed;
	1553	}
	1554	else {
	1555	$formatted->returns['types'][] = array(
	1556	'title' => $type
	1557	);
	1558	}
	1559	}
	1560	case 'parameters':
	1561	$formatted->parameters = _jsdoc_get_parameters_themed($node, true);
	1562	if (!count($formatted->parameters)) {
	1563	unset($formatted->parameters);
	1564	}
	1565	break;
	1566	}
	1567	}
	1568	if ($_JSON['recursive']) {
	1569	$children = array_keys(jsdoc_get_child_variables($node));
	1570	if (!empty($children))
	1571	$formatted->children = jsdoc_jsonp(true, array(
	1572	'attributes' => $_JSON['attributes'],
	1573	'names' => $children,
	1574	'recursive' => $_JSON['recursive']
	1575	));
	1576	}
	1577	$output[] = $formatted;
	1578	}
	1579	}
	1580
	1581	$found = array();
	1582	foreach ($output as $object) {
	1583	$found[] = $object->name;
	1584	}
	1585	foreach (array_diff($names, $found) as $name) {
	1586	$output[] = (object)array(
	1587	'name' => $name
	1588	);
	1589	}
	1590
	1591	if ($recursion) {
	1592	return $output;
	1593	}
	1594	print $_GET['callback'] . '(' . str_replace('"__className":"stdClass",', '', json_encode($output)) . ');';
	1595	}
	1596
	1597	function jsdoc_get_closest($name, $version) {
	1598	$node = jsdoc_object_node_load($name, $version);
	1599	if (!$node->nid) {
	1600	$parts = explode('.', $name);
	1601	while (!$node->nid) {
	1602	array_pop($parts);
	1603	if (empty($parts)) {
	1604	break;
	1605	}
	1606	$node = jsdoc_object_node_load(implode('.', $parts), $version);
	1607	}
	1608	}
	1609	return $node;
	1610	}
	1611
	1612	function _jsdoc_resolve_child($node, $name) {
	1613	list($prototype_chain, $mixin_chain, $children) = jsdoc_get_oo_info($node, $name);
	1614
	1615	$actual = (object)array(
	1616	'title' => $name,
	1617	'jsdoc_version' => jsdoc_get_version($node)
	1618	);
	1619
	1620	foreach ($children as $possible) {
	1621	if ($possible->title == $name \|\| $node->title . '.' . $possible->title == $name) {
	1622	$actual = $possible->node;
	1623	$actual->type = $possible->type;
	1624	unset($actual->jsdoc_type);
	1625	break;
	1626	}
	1627	}
	1628
	1629	$actual->format = $node->format;
	1630	$actual->title = $name;
	1631
	1632	if (empty($actual->teaser) && empty($actual->body)) {
	1633	$actual->teaser = ' ';
	1634	$actual->body = ' ';
	1635	}
	1636
	1637	return $actual;
	1638	}
	1639
	1640	/**
	1641	* A menu callback
	1642	* Will only ever be a function or property
	1643	*/
	1644	function jsdoc_child_node_view($node, $name) {
	1645	$actual = _jsdoc_resolve_child($node, $name);
	1646
	1647	drupal_set_title(theme('jsdoc_object_title', _jsdoc_get_title_themed($actual)));
	1648
	1649	$form = _jsdoc_node_prepare($actual);
	1650
	1651	if ($provide = jsdoc_get_provide($actual)) {
	1652	$form['require'] = array(
	1653	'#value' => theme('jsdoc_object_require', $provide),
	1654	'#weight' => -20
	1655	);
	1656	}
	1657
	1658	if ($resource = jsdoc_get_resource($actual)) {
	1659	$form['resource'] = array(
	1660	'#value' => theme('jsdoc_object_resource', jsdoc_get_resource($node))
	1661	);
	1662	}
	1663
	1664	$examples = array();
	1665	foreach (jsdoc_get_examples($actual, true) as $weight => $example) {
	1666	$examples[] = theme('jsdoc_object_example', $example, $weight + 1);
	1667	}
	1668	if (!empty($examples)) {
	1669	$form['examples'] = array(
	1670	'#value' => theme('jsdoc_object_examples', $examples),
	1671	'#weight' => 35
	1672	);
	1673	}
	1674
	1675	if (jsdoc_is_function($actual)) {
	1676	$parameters = _jsdoc_get_parameters_themed($actual);
	1677
	1678	if (count($parameters)) {
	1679	$form['parameters'] = array(
	1680	'#value' => theme('jsdoc_function_parameters', $parameters, _jsdoc_get_object_themed($actual, $actual->title)),
	1681	'#weight' => 20
	1682	);
	1683	}
	1684
	1685	$function = (object)array(
	1686	'source' => jsdoc_get_source($actual, true),
	1687	'markedup' => _jsdoc_markup_code(jsdoc_get_source($actual, true), jsdoc_get_version($node)->nid, $actual->title, FALSE),
	1688	'signature' => _jsdoc_build_function_signature($actual, $parameters)
	1689	);
	1690	if (count($parameters)) {
	1691	$function->parameters = $parameters;
	1692	}
	1693
	1694	$form['function'] = array(
	1695	'#value' => theme('jsdoc_function_information', $function, $children, _jsdoc_get_object_themed($actual, $actual->title)),
	1696	'#weight' => 30
	1697	);
	1698	}
	1699	elseif (($object = jsdoc_object_node_load(jsdoc_get_type($actual), jsdoc_get_version($node))) && $object->nid) {
	1700	list($prototype_chain, $mixin_chain, $children) = jsdoc_get_oo_info($object);
	1701
	1702	$theme_children = array();
	1703	foreach ($children as $child) {
	1704	if ($child->instance \|\| $child->prototype) {
	1705	$theme_children[] = $child;
	1706	}
	1707	}
	1708
	1709	if (count($theme_children)) {
	1710	$form['children'] = array(
	1711	'#value' => theme('jsdoc_object_children', $theme_children),
	1712	'#weight' => 40
	1713	);
	1714	}
	1715	}
	1716
	1717	return drupal_render_form('jsdoc_child_form', $form);
	1718	}
	1719
	1720	/**
	1721	* Climbs up the prototype chain through mixins
	1722	*
	1723	* Move down the prototype chain
	1724	* The prototype chains of the parents have already been calculated
	1725	* For each one, inject its resolved mixins above the current class
	1726	*/
	1727	function _jsdoc_resolve_mixins($node, $from) {
	1728	$resolved_mixins = array();
	1729
	1730	$all_mixins = array();
	1731	if ($from == 'prototype') {
	1732	$prototype_chain = jsdoc_get_prototype_chain($node);
	1733	foreach ($prototype_chain as $parent) {
	1734	if (!$parent->nid) { continue; }
	1735	$all_mixins[] = $parent;
	1736	}
	1737	}
	1738	$all_mixins[] = $node;
	1739
	1740	foreach ($all_mixins as $parent) {
	1741	foreach (jsdoc_get_mixins($parent, $from) as $mixin) {
	1742	foreach (_jsdoc_resolve_mixins($mixin->node, $from) as $other_mixin) {
	1743	if (!$other_mixin->node->nid) { continue; }
	1744	$resolved_mixins[] = $other_mixin;
	1745	}
	1746	$resolved_mixins[] = $mixin;
	1747	}
	1748	$resolved_mixins[] = (object)array(
	1749	'attached' => $node,
	1750	'scope' => 'prototype',
	1751	'node' => $parent
	1752	);
	1753	}
	1754
	1755	for ($i = 0; $i < count($resolved_mixins); $i++) {
	1756	for ($j = $i + 1; $j < count($resolved_mixins); $j++) {
	1757	if ($resolved_mixins[$i]->node->title == $resolved_mixins[$j]->node->title) {
	1758	array_splice($resolved_mixins, $i, 1);
	1759	continue 2;
	1760	}
	1761	}
	1762	}
	1763
	1764	return $resolved_mixins;
	1765	}
	1766
	1767	function jsdoc_get_oo_info(&$node, $child=NULL) {
	1768	if (isset($node->jsdoc_oo_info)) {
	1769	return $node->jsdoc_oo_info;
	1770	}
	1771
	1772	$returned_mixin_chain = array();
	1773	$mixin_chain = array();
	1774
	1775	if (jsdoc_is_classlike($node)) {
	1776	$prototype_chain = jsdoc_get_prototype_chain($node);
	1777
	1778	// Start out with simply the prototype chain
	1779	$prototype_chain_values = array();
	1780	foreach ($prototype_chain as $prototype) {
	1781	if ($prototype->nid) {
	1782	$prototype_chain_values[] = $prototype->title;
	1783	}
	1784	}
	1785
	1786	// Resolve prototype-level items
	1787	foreach (_jsdoc_resolve_mixins($node, 'prototype') as $mixin) {
	1788	$mixin_chain[] = (object)array(
	1789	'attached' => $mixin->attached,
	1790	'scope' => 'prototype',
	1791	'from' => $mixin->scope,
	1792	'methods' => jsdoc_get_methods($mixin->node, $mixin->scope),
	1793	'properties' => jsdoc_get_properties($mixin->node, $mixin->scope),
	1794	'in_prototype_chain' => in_array($mixin->node->title, $prototype_chain_values),
	1795	'node' => $mixin->node
	1796	);
	1797	}
	1798
	1799	$returned_mixin_chain = array();
	1800	$returned_mixin_titles = array();
	1801	foreach ($mixin_chain as $mixin) {
	1802	if ($mixin->in_prototype_chain \|\| $mixin->attached->title == $node->title) {
	1803	if ($mixin->node->title != $node->title && !$returned_mixin_titles[$mixin->node->title]) {
	1804	$returned_mixin_titles[$mixin->node->title] = TRUE;
	1805	$returned_mixin_chain[] = $mixin;
	1806	}
	1807	}
	1808	}
	1809
	1810	$mixin_chain[] = (object)array(
	1811	'scope' => 'prototype',
	1812	'from' => 'prototype',
	1813	'methods' => jsdoc_get_methods($node, 'prototype'),
	1814	'properties' => jsdoc_get_properties($node, 'prototype'),
	1815	'in_prototype_chain' => true,
	1816	'node' => $node
	1817	);
	1818
	1819	// Now with instance-level items
	1820
	1821	foreach (_jsdoc_resolve_mixins($node, 'instance') as $mixin) {
	1822	$mixin_chain[] = (object)array(
	1823	'scope' => 'instance',
	1824	'from' => $mixin->scope,
	1825	'methods' => jsdoc_get_methods($mixin->node, $mixin->scope),
	1826	'properties' => jsdoc_get_properties($mixin->node, $mixin->scope),
	1827	'in_prototype_chain' => in_array($mixin->node->title, $prototype_chain_values),
	1828	'node' => $mixin->node
	1829	);
	1830	}
	1831
	1832	$mixin_chain[] = (object)array(
	1833	'scope' => 'instance',
	1834	'from' => 'instance',
	1835	'methods' => jsdoc_get_methods($node, 'instance'),
	1836	'properties' => jsdoc_get_properties($node, 'instance'),
	1837	'in_prototype_chain' => false,
	1838	'node' => $node
	1839	);
	1840
	1841	array_pop($prototype_chain);
	1842	}
	1843
	1844	$mixin_chain[] = (object)array(
	1845	'scope' => 'normal',
	1846	'from' => 'instance',
	1847	'methods' => jsdoc_get_methods($node, 'normal'),
	1848	'properties' => jsdoc_get_properties($node, 'normal'),
	1849	'in_prototype_chain' => false,
	1850	'node' => $node
	1851	);
	1852
	1853	$child_attribute = false;
	1854	if ($child) {
	1855	list($child_attribute) = array_slice(explode('.', $child), -1);
	1856	}
	1857	$children = array();
	1858	foreach ($mixin_chain as $mixin) {
	1859	foreach (array('methods', 'properties') as $child_type) {
	1860	foreach ($mixin->$child_type as $item) {
	1861	list($item_attribute) = array_slice(explode('.', $item->title), -1);
	1862
	1863	if ($child_attribute && $item_attribute != $child_attribute) {
	1864	continue;
	1865	}
	1866
	1867	if ($mixin->scope == 'normal') {
	1868	$title = $item->title;
	1869	}
	1870	else {
	1871	$title = $item_attribute;
	1872	}
	1873
	1874	if (jsdoc_get_type($item) == 'Constructor' && ($resolved = jsdoc_resolve_constructor($item))) {
	1875	$item->jsdoc_parameters = $resolved->jsdoc_parameters;
	1876	$item->jsdoc_return_summary = $resolved->jsdoc_return_summary;
	1877	$item->jsdoc_return_types = $resolved->jsdoc_return_types;
	1878	$item->teaser = $resolved->teaser;
	1879	}
	1880
	1881	if ($children[$title]) {
	1882	$found = false;
	1883	if ($children[$title]->inheritance) {
	1884	foreach ($children[$title]->inheritance as $parent) {
	1885	if ($parent->title == $mixin->node->title) {
	1886	$found = true;
	1887	break;
	1888	}
	1889	}
	1890	}
	1891	if (!$found) {
	1892	if ($mixin->node->title == $node->title) {
	1893	$children[$title]->override = true;
	1894	}
	1895	else {
	1896	$children[$title]->inheritance[] = _jsdoc_get_object_themed($mixin->node);
	1897	}
	1898	$inherited = _jsdoc_get_object_themed($item, $title);
	1899	foreach ($inherited as $key => $value) {
	1900	if ($key == 'summary' && trim($value) == '') {
	1901	continue;
	1902	}
	1903	$children[$title]->$key = $value;
	1904	}
	1905	}
	1906	}
	1907	else {
	1908	$children[$title] = _jsdoc_get_object_themed($item, $title);
	1909	$children[$title]->node = $item;
	1910	if ($mixin->node->title != $node->title && ($mixin->scope != 'normal' \|\| implode('.', array_slice(explode('.', $title), 0, -1)) != $node->title)) {
	1911	$children[$title]->inheritance[] = _jsdoc_get_object_themed($mixin->node);
	1912	}
	1913	}
	1914
	1915	$scope = $mixin->scope;
	1916	$children[$title]->$scope = TRUE;
	1917
	1918	if ($title == $item->title) {
	1919	$children[$title]->actual_title = $title;
	1920	}
	1921	else {
	1922	$children[$title]->actual_title = $mixin->node->title . '.' . $title;
	1923	}
	1924
	1925	$type = $item->jsdoc_scope;
	1926	$children[$title]->$type = true;
	1927
	1928	if (trim(jsdoc_get_teaser($item)) != '') {
	1929	$children[$title]->summary = jsdoc_get_teaser($item);
	1930	}
	1931	}
	1932	}
	1933	}
	1934	uksort($children, "strnatcasecmp");
	1935
	1936	return ($node->jsdoc_oo_info = array($prototype_chain, $returned_mixin_chain, $children));
	1937	}
	1938
	1939	/**
	1940	* A menu callback
	1941	* Will only ever be a constructor or namespace
	1942	*/
	1943	function jsdoc_object_node_view($node) {
	1944	ini_set('memory_limit', '128M');
	1945	// Test for the basics
	1946	if (!$node) {
	1947	return drupal_not_found();
	1948	}
	1949
	1950	drupal_set_title(theme('jsdoc_object_title', _jsdoc_get_title_themed($node)));
	1951
	1952	if (empty($node->teaser) && empty($node->body)) {
	1953	$node->teaser = ' ';
	1954	$node->body = ' ';
	1955	}
	1956
	1957	$form = _jsdoc_node_prepare($node);
	1958
	1959	if ($provide = jsdoc_get_provide($node)) {
	1960	$form['require'] = array(
	1961	'#value' => theme('jsdoc_object_require', $provide),
	1962	'#weight' => -20
	1963	);
	1964	}
	1965
	1966	if ($resource = jsdoc_get_resource($node)) {
	1967	$form['resource'] = array(
	1968	'#value' => theme('jsdoc_object_resource', jsdoc_get_resource($node))
	1969	);
	1970	}
	1971
	1972	$examples = array();
	1973	foreach (jsdoc_get_examples($node, true) as $weight => $example) {
	1974	$examples[] = theme('jsdoc_object_example', $example, $weight + 1);
	1975	}
	1976	if (!empty($examples)) {
	1977	$form['examples'] = array(
	1978	'#value' => theme('jsdoc_object_examples', $examples),
	1979	'#weight' => 35
	1980	);
	1981	}
	1982
	1983	list($prototype_chain, $mixin_chain, $children) = jsdoc_get_oo_info($node);
	1984
	1985	if (jsdoc_is_classlike($node)) {
	1986	$form['prototype_chain'] = array(
	1987	'#value' => theme('jsdoc_object_prototype_chain', $prototype_chain),
	1988	'#weight' => 10
	1989	);
	1990	}
	1991
	1992	if (!empty($mixin_chain)) {
	1993	$form['parent_mixins'] = array(
	1994	'#value' => theme('jsdoc_object_mixins', $mixin_chain),
	1995	'#weight' => 40
	1996	);
	1997	}
	1998
	1999	if (jsdoc_is_function($node)) {
	2000	$actual = $node;
	2001	if (jsdoc_is_classlike($node)) {
	2002	$actual = jsdoc_resolve_constructor($node);
	2003	}
	2004
	2005	$parameters = _jsdoc_get_parameters_themed($actual);
	2006
	2007	if (count($parameters)) {
	2008	$form['parameters'] = array(
	2009	'#value' => theme('jsdoc_function_parameters', $parameters, _jsdoc_get_object_themed($node, $node->title)),
	2010	'#weight' => 20
	2011	);
	2012	}
	2013
	2014	$base = false;
	2015	if (jsdoc_get_type($node) == 'Constructor') {
	2016	$base = $node->title;
	2017	}
	2018
	2019	$function = (object)array(
	2020	'source' => jsdoc_get_source($actual, true),
	2021	'markedup' => _jsdoc_markup_code(jsdoc_get_source($actual, true), jsdoc_get_version($node)->nid, $actual->title, $base),
	2022	'signature' => _jsdoc_build_function_signature($actual, $parameters)
	2023	);
	2024	if (count($parameters)) {
	2025	$function->parameters = $parameters;
	2026	}
	2027
	2028	$form['function'] = array(
	2029	'#value' => theme('jsdoc_function_information', $function, $children, _jsdoc_get_object_themed($node, $node->title)),
	2030	'#weight' => 30
	2031	);
	2032	}
	2033
	2034	if (count($children)) {
	2035	$form['children'] = array(
	2036	'#value' => theme('jsdoc_object_children', $children),
	2037	'#weight' => 40
	2038	);
	2039	}
	2040
	2041	if (function_exists('comment_render') && $node->comment) {
	2042	$form['comments'] = array(
	2043	'#value' => comment_render($node),
	2044	'#weight' => 50
	2045	);
	2046	}
	2047
	2048	return drupal_render_form('jsdoc_object_form', $form);
	2049	}
	2050
	2051	function _jsdoc_get_title_themed($node) {
	2052	$themed = _jsdoc_get_object_themed($node);
	2053	$themed->crumbs = array();
	2054
	2055	if ($type = jsdoc_get_type($node)) {
	2056	$type = jsdoc_object_node_load($type, jsdoc_get_version($node));
	2057	$themed->type = (object)array(
	2058	'title' => $type->title,
	2059	'url' => $type->jsdoc_url
	2060	);
	2061	if ($type->jsdoc_url) {
	2062	$themed->type->a = l($type->title, $type->jsdoc_url);
	2063	}
	2064	else {
	2065	$themed->type->a = $type->title;
	2066	}
	2067	}
	2068
	2069	$themed->return = (object)array(
	2070	'types' => array(),
	2071	'summary' => jsdoc_get_return_summary($node)
	2072	);
	2073	foreach (jsdoc_get_return_types($node) as $type) {
	2074	$themed->return->types[] = _jsdoc_get_type_themed($type->type, $node, false);
	2075	}
	2076
	2077	$parts = explode('.', $node->title);
	2078	$title_text = "";
	2079	$end = array_pop($parts);
	2080	foreach ($parts as $part) {
	2081	if (!empty($title_text)) {
	2082	$title_text .= '.';
	2083	}
	2084	$title_text .= $part;
	2085
	2086	$obj = jsdoc_object_node_load($title_text, jsdoc_get_version($node));
	2087	if ($obj->nid) {
	2088	$themed->crumbs[] = l($part, $obj->jsdoc_url);
	2089	}
	2090	else {
	2091	$themed->crumbs[] = $part;
	2092	}
	2093	}
	2094	$themed->crumbs[] = $end;
	2095
	2096	drupal_set_breadcrumb($themed->crumbs);
	2097
	2098	return $themed;
	2099	}
	2100
	2101	function _jsdoc_get_object_themed(&$node, $title=null, $depth=0) {
	2102	if (is_null($title)) {
	2103	$title = $node->title;
	2104	}
	2105	if (isset($node->jsdoc_object_themed)) {
	2106	return $node->jsdoc_object_themed;
	2107	}
	2108
	2109	$object = $node->jsdoc_object_themed = (object)array(
	2110	'title' => $title,
	2111	'url' => $node->jsdoc_url,
	2112	'tags' => jsdoc_get_tags($node),
	2113	'summary' => jsdoc_get_teaser($node),
	2114	'singleton' => jsdoc_is_initialized($node),
	2115	'namespace' => jsdoc_is_namespace($node) && !jsdoc_is_classlike($node),
	2116	'private' => jsdoc_is_private($node),
	2117	'protected' => jsdoc_is_protected($node),
	2118	'deprecated' => jsdoc_is_deprecated($node),
	2119	'private_parent' => jsdoc_has_private_parent($node)
	2120	);
	2121
	2122	if ($object->url) {
	2123	$object->a = l($node->title, $node->jsdoc_url);
	2124	}
	2125	else {
	2126	$object->a = $object->title;
	2127	}
	2128
	2129	if ($type = jsdoc_get_type($node)) {
	2130	$optional = false;
	2131	if (strpos($type, '?') !== false){
	2132	$optional = true;
	2133	$type = str_replace('?', '', $type);
	2134	}
	2135	$repeating = false;
	2136	if (strpos($type, '...') !== false){
	2137	$repeating = true;
	2138	$type = str_replace('...', '', $type);
	2139	}
	2140
	2141	$type = jsdoc_object_node_load($type, jsdoc_get_version($node));
	2142
	2143	$object->type = (object)array(
	2144	'title' => $type->title,
	2145	'url' => $type->jsdoc_url,
	2146	'optional' => $optional,
	2147	'repeating' => $repeating
	2148	);
	2149
	2150	if ($type->jsdoc_url) {
	2151	$object->type->a = l($type->title, $type->jsdoc_url);
	2152	}
	2153	else {
	2154	$object->type->a = $type->title;
	2155	}
	2156
	2157	if (jsdoc_is_function($node)) {
	2158	$parameters = _jsdoc_get_parameters_themed($node, false, $depth);
	2159	if (!empty($parameters)) {
	2160	$object->parameters = $parameters;
	2161	}
	2162
	2163	$object->return = (object)array(
	2164	'types' => array(),
	2165	'summary' => jsdoc_get_return_summary($node)
	2166	);
	2167	foreach (jsdoc_get_return_types($node) as $type) {
	2168	$object->return->types[] = _jsdoc_get_type_themed($type->type, $node, false);
	2169	}
	2170
	2171	$signature = _jsdoc_build_function_signature($node, $parameters);
	2172	if (!empty($signature)) {
	2173	$object->signature = $signature;
	2174	}
	2175
	2176	$source = jsdoc_get_source($node, true, $depth);
	2177	if (!empty($source)) {
	2178	$object->source = $source;
	2179	}
	2180	}
	2181	}
	2182
	2183	return ($node->jsdoc_object_themed = $object);
	2184	}
	2185
	2186	function jsdoc_resolve_constructor(&$node) {
	2187	if ($node->jsdoc_resolved_constructor) {
	2188	return $node->jsdoc_resolved_constructor;
	2189	}
	2190
	2191	if ($node->jsdoc_constructor) {
	2192	$constructor = (object)array();
	2193	_jsdoc_convert_object($constructor, $node->jsdoc_constructor, $node, TRUE);
	2194	return ($node->jsdoc_resolved_constructor = $constructor);
	2195	}
	2196
	2197	$superclass = jsdoc_get_parent_prototype($node);
	2198	while ($superclass) {
	2199	$constructor = (object)array();
	2200	_jsdoc_convert_object($constructor, $superclass->jsdoc_constructor, $node, TRUE);
	2201	if ($constructor->jsdoc_parameters) {
	2202	return ($node->jsdoc_resolved_constructor = $constructor);
	2203	}
	2204	$superclass = jsdoc_get_parent_prototype($superclass);
	2205	}
	2206
	2207	return ($node->jsdoc_resolved_constructor = $node->jsdoc_constructor);
	2208	}
	2209
	2210	function _jsdoc_get_fields($type, &$node) {
	2211	// I basically want to find the children of this as
	2212	// if it appeared in the normal API.
	2213	static $cache = array();
	2214	$version = jsdoc_get_version($node);
	2215	if (isset($cache[$version->title][$type])) {
	2216	return $cache[$version->title][$type];
	2217	}
	2218
	2219	$fields = $cache[$version->title][$type] = array();
	2220	$obj = jsdoc_object_node_load($type, $version, TRUE, TRUE);
	2221	// It will have an nid if it's local. For example type: Function isn't local
	2222	if ($obj && $obj->nid) {
	2223	list($prototype_chain, $mixin_chain, $children) = jsdoc_get_oo_info($obj);
	2224
	2225	foreach ($children as $child) {
	2226	$title = $child->title;
	2227
	2228	$field = (object)array(
	2229	'title' => $title,
	2230	'summary' => $child->summary,
	2231	'types' => false
	2232	);
	2233	if (!$cleaned) {
	2234	$field->url = 'jsdoc/' . $version->title . '/' . $obj->title . '.' . $child->title;
	2235	$field->a = l($title, $field->url);
	2236	}
	2237
	2238	$field_types = preg_split('%\\|+%', jsdoc_get_type($child));
	2239	foreach ($field_types as $field_type) {
	2240	$found = 0;
	2241	$field_type = str_replace('?', '', $field_type, $found);
	2242	$optional = ($found > 0);
	2243	$found = 0;
	2244	$field_type = str_replace('...', '', $field_type, $found);
	2245	$repeating = ($found > 0);
	2246
	2247	$field_obj = jsdoc_object_node_load($field_type, $version);
	2248	$field_type = (object)array(
	2249	'title' => $field_obj->title,
	2250	'repeating' => $repeating,
	2251	'optional' => $optional,
	2252	'summary' => jsdoc_get_teaser($field_obj)
	2253	);
	2254	if (!$cleaned) {
	2255	$field_type->url = $field_obj->jsdoc_url;
	2256	$field_type->a = l($field_obj->title, $field_obj->jsdoc_url);
	2257	}
	2258	$field->types[] = $field_type;
	2259	}
	2260
	2261	$fields[$field->title] = $field;
	2262	}
	2263
	2264	if (empty($fields)) {
	2265	return;
	2266	}else{
	2267	uksort($fields, 'strnatcasecmp');
	2268	return ($cache[$version->title][$type] = $fields);
	2269	}
	2270	}
	2271	}
	2272
	2273	function _jsdoc_get_type_themed($type, $node, $cleaned){
	2274	$obj = jsdoc_object_node_load($type, jsdoc_get_version($node), TRUE, TRUE);
	2275	if ($obj) {
	2276	$type = (object)array(
	2277	'title' => $obj->title,
	2278	'summary' => jsdoc_get_teaser($obj),
	2279	'fields' => false
	2280	);
	2281	if (!$cleaned && $obj->jsdoc_url) {
	2282	$type->url = $obj->jsdoc_url;
	2283	$type->a = l($obj->title, $obj->jsdoc_url);
	2284	}
	2285
	2286	return $type;
	2287	}
	2288	}
	2289
	2290	function _jsdoc_get_parameters_themed(&$node, $cleaned=false) {
	2291	if (isset($node->jsdoc_parameters_themed)) {
	2292	return $node->jsdoc_parameters_themed;
	2293	}
	2294
	2295	$parameters = $node->jsdoc_parameters_themed = array();
	2296	$retrieved_parameters = jsdoc_get_parameters($node);
	2297
	2298	foreach ($retrieved_parameters as $item) {
	2299	$parameter = (object)$item->jsdoc_formatted;
	2300	$parameter->summary = $item->summary;
	2301	$parameter->name = $item->name;
	2302	$parameter->optional = $item->usage == 'optional';
	2303	$parameter->repeating = $item->usage == 'repeating' \|\| $item->usage == 'one-or-more';
	2304	$parameter->types = false;
	2305	if ($cleaned) {
	2306	unset($parameter->html_type_prefix);
	2307	unset($parameter->html_type_suffix);
	2308	unset($parameter->separator);
	2309	}
	2310
	2311	$type = $item->type;
	2312	$types = array();
	2313	if (strpos($type, '\|') !== false) {
	2314	$types = preg_split('%\s\\|+\s%', $type);
	2315	}
	2316	elseif ($type) {
	2317	$types = array($type);
	2318	}
	2319
	2320	foreach ($types as $type) {
	2321	if ($type = _jsdoc_get_type_themed($type, $node, $cleaned)) {
	2322	$type->fields = _jsdoc_get_fields($type->title, $node);
	2323	$parameter->types[] = $type;
	2324	}
	2325	}
	2326
	2327	if (empty($parameter->types)) {
	2328	unset($parameter->html_type_prefix);
	2329	unset($parameter->html_type_suffix);
	2330	unset($parameter->separator);
	2331	}
	2332
	2333	unset($parameter->type);
	2334	$parameters[] = $parameter;
	2335	}
	2336
	2337	return ($node->jsdoc_parameters_themed = $parameters);
	2338	}
	2339
	2340	function _jsdoc_format_type($type, $classlike = false, $optional = false, $repeating = false) {
	2341	$output = array();
	2342	$name = '';
	2343
	2344	if ($type) {
	2345	$output['html_type_prefix'] = '/*';
	2346	$output['html_type_suffix'] = '*/';
	2347	$output['type'] = $type;
	2348	if ($type == 'Function' && $classlike) {
	2349	$output['type'] = 'Constructor';
	2350	}
	2351	if ($optional) {
	2352	$output['type'] .= '?';
	2353	}
	2354	if ($repeating) {
	2355	$output['type'] .= '...';
	2356	}
	2357	}
	2358	if ($type) {
	2359	$output['separator'] .= ' ';
	2360	}
	2361
	2362	return $output;
	2363	}
	2364
	2365	function _jsdoc_flatten(&$item, $key) {
	2366	if (is_object($item)) {
	2367	$item = $item->title;
	2368	}
	2369	}
	2370
	2371	function jsdoc_get_namespace_parents(&$node) {
	2372	if (isset($node->jsdoc_namespace_parents)) {
	2373	return $node->jsdoc_namespace_parents;
	2374	}
	2375
	2376	$parents = array();
	2377
	2378	$parts = explode('.', $node->title);
	2379	array_pop($parts);
	2380	while (count($parts)) {
	2381	$parents[] = jsdoc_object_node_load(implode('.', $parts), jsdoc_get_version($node));
	2382	array_pop($parts);
	2383	}
	2384
	2385	return ($node->jsdoc_namespace_parents = $parents);
	2386	}
	2387
	2388	function jsdoc_get_prototype_chain(&$node) {
	2389	if (isset($node->jsdoc_prototype_chain)) {
	2390	return $node->jsdoc_prototype_chain;
	2391	}
	2392
	2393	$chain = array($node);
	2394
	2395	$superclass = $node->jsdoc_superclass;
	2396	while ($superclass) {
	2397	$superclass = jsdoc_object_node_load($superclass, jsdoc_get_version($node));
	2398	$chain[] = $superclass;
	2399	$superclass = $superclass->jsdoc_superclass;
	2400	}
	2401
	2402	$chain[] = jsdoc_object_node_load('Object');
	2403
	2404	return ($node->jsdoc_prototype_chain = array_reverse($chain));
	2405	}
	2406
	2407	function jsdoc_current_node($node=null) {
	2408	static $current;
	2409	if (is_null($node)) {
	2410	return $current;
	2411	}
	2412	$current = $node;
	2413	}
	2414
	2415	function _jsdoc_build_function_signature($node, $parameters) {
	2416	if (isset($node->jsdoc_function_signature)) {
	2417	return $node->jsdoc_function_signature;
	2418	}
	2419
	2420	if (jsdoc_get_type($node) != 'Function' && jsdoc_get_type($node) != 'Constructor') {
	2421	return;
	2422	}
	2423
	2424	$signature = '(';
	2425
	2426	if ($parameters) {
	2427	foreach ($parameters as $weight => $parameter) {
	2428	if ($weight) {
	2429	$signature .= ', ';
	2430	}
	2431	$types = array();
	2432	if ($parameter->types) {
	2433	foreach ($parameter->types as $type) {
	2434	$types[] = $type->a;
	2435	}
	2436	}
	2437	$signature .= $parameter->html_type_prefix . implode('\|', $types);
	2438	if ($parameter->optional) {
	2439	$signature .= '?';
	2440	}
	2441	if ($parameter->repeating) {
	2442	$signature .= '...';
	2443	}
	2444	$signature .= $parameter->html_type_suffix . $parameter->separator . $parameter->name;
	2445	}
	2446	}
	2447
	2448	$signature .= ')';
	2449
	2450	return ($node->jsdoc_function_signature = $signature);
	2451	}
	2452
	2453	function _jsdoc_resource_expand($tree, $child, $depth, &$resources){
	2454	$output = array();
	2455	foreach ($tree as $leaf) {
	2456	if ($leaf->depth == $depth && in_array($child, $leaf->children) && !in_array($leaf->vid, $resources)) {
	2457	$resources[] = $leaf->vid;
	2458	$output[] = $leaf;
	2459	}
	2460	}
	2461
	2462	return $output;
	2463	}
	2464
	2465	function _jsdoc_file_location() {
	2466	static $location;
	2467
	2468	if (!isset($location)) {
	2469	$location = variable_get('jsdoc_file_location', false);
	2470	}
	2471
	2472	return $location;
	2473	}
	2474
	2475	function _jsdoc_dir_location() {
	2476	static $location;
	2477
	2478	if (!isset($location)) {
	2479	$location = variable_get('jsdoc_dir_location', false);
	2480	}
	2481
	2482	return $location;
	2483	}
	2484
	2485	function _jsdoc_base() {
	2486	static $base;
	2487
	2488	if (!isset($base)) {
	2489	$base = variable_get('jsdoc_base', 'jsdoc');
	2490	}
	2491
	2492	return $base;
	2493	}
	2494
	2495	function _jsdoc_build_terms($title) {
	2496	$output = array($title, array());
	2497	$parts = explode('.', $title);
	2498	foreach ($parts as $part) {
	2499	if (preg_match('%^[_.$]([a-zA-Z][a-z0-9_.$](?:[A-Z][a-z0-9_.$]*)+)%', $part, $match)) {
	2500	if (preg_match_all('%(^[a-zA-Z][a-z0-9_.$]\|[A-Z][a-z0-9_.$])%', $match[1], $cased)) {
	2501	$output[1] = array_merge($output[1], $cased[0]);
	2502	}
	2503	}
	2504	}
	2505	$output[1] = implode(' ', $output[1]);
	2506	$output[2] = implode(' ', $parts);
	2507	return $output;
	2508	}
	2509
	2510	function _jsdoc_get_base_path() {
	2511	static $path;
	2512
	2513	if (!isset($path)) {
	2514	$path = getcwd();
	2515	}
	2516
	2517	return $path;
	2518	}
	2519
	2520	function _jsdoc_cron_chdir($enter=false) {
	2521	static $location;
	2522
	2523	if ($enter) {
	2524	$location = _jsdoc_get_base_path();
	2525	if (!is_dir(_jsdoc_dir_location())){
	2526	print t('Check Drupal logs for errors');
	2527	watchdog('jsdoc', _jsdoc_dir_location() . t(' should be a directory'), WATCHDOG_ERROR);
	2528	return false;
	2529	}
	2530	if (!@chdir(_jsdoc_dir_location())) {
	2531	print t('Check Drupal logs for errors');
	2532	watchdog('jsdoc', _jsdoc_dir_location() . t(' could not be accessed'), WATCHDOG_ERROR);
	2533	return false;
	2534	}
	2535	include_once(_jsdoc_file_location());
	2536	}
	2537	else {
	2538	chdir($location);
	2539	}
	2540	}
	2541
	2542	// Private Utility Functions
	2543	// =========================
	2544
	2545	function _jsdoc_theme_clone($node) {
	2546	$clone = drupal_clone($node);
	2547	foreach ($clone as $key => $value) {
	2548	if (substr($key, 0, 6) == 'jsdoc_') {
	2549	unset($clone->$key);
	2550	}
	2551	}
	2552	return $clone;
	2553	}
	2554
	2555	function _jsdoc_node_prepare($node) {
	2556	$node->format = variable_get('jsdoc_input_format', 1);
	2557
	2558	$form = node_prepare($node)->content;
	2559	$form['summary']['#weight'] = $form['body']['#weight'] - 1;
	2560
	2561	$teaser = jsdoc_get_teaser($node);
	2562	if (!$node->body \|\| $node->body == t('n/a')) {
	2563	$node->body = $teaser;
	2564	$teaser = '';
	2565	}
	2566	$body = jsdoc_get_body($node);
	2567	if ($body == t('n/a')) {
	2568	$body = '';
	2569	}
	2570
	2571	$form['summary']['#value'] = theme('jsdoc_object_summary', $teaser);
	2572	$form['description']['#value'] = theme('jsdoc_object_description', $teaser, $body);
	2573
	2574	unset($form['body']);
	2575
	2576	return $form;
	2577	}
	2578
	2579	function _jsdoc_get_variables() {
	2580	static $variables;
	2581	if (empty($variables)) {
	2582	if ($variables = cache_get('jsdoc_variables')) {
	2583	$variables = unserialize($variables->data);
	2584	}
	2585	else {
	2586	$variables = array();
	2587	$query = db_query("SELECT variable FROM {jsdoc_variables}");
	2588	while ($variable = db_fetch_object($query)) {
	2589	if (preg_match('%^(dojo\|dijit\|dojox)\.%', $variable->variable)) {
	2590	$variables[$variable->variable] = TRUE;
	2591	}
	2592	}
	2593	cache_set('jsdoc_variables', 'cache', serialize($variables), time() + 86400);
	2594	}
	2595	}
	2596
	2597	return $variables;
	2598	}
	2599
	2600	function _jsdoc_markup_code($text, $version, $exclude, $base=false) {
	2601	$variables = _jsdoc_get_variables();
	2602
	2603	$min = 99;
	2604	$lines = preg_split('%\r?\n%', $text);
	2605	foreach ($lines as $line) {
	2606	if (!empty($line)) {
	2607	if (preg_match('%^\t+%', $line, $match)) {
	2608	if (strlen($match[0]) < $min) {
	2609	$min = strlen($match[0]);
	2610	}
	2611	}
	2612	}
	2613	}
	2614	if ($min) {
	2615	foreach ($lines as $i => $line) {
	2616	$lines[$i] = preg_replace('%^\t{' . $min . '}%', '', $line);
	2617	}
	2618	}
	2619	$text = implode("\n", $lines);
	2620
	2621	_jsdoc_init();
	2622	$language = 'javascript';
	2623	if (preg_match('%(^\W<\|>\W$)%', $text)) {
	2624	$language = 'html4strict';
	2625	}
	2626	$highlighter =& new GeSHi($text, $language);
	2627	$highlighter->enable_classes();
	2628	$highlighter->enable_keyword_links(false);
	2629	$highlighter->set_overall_style('color: #666;', true);
	2630	$highlighter->set_tab_width(4);
	2631	$highlighter->add_keyword_group(4, '', true, array('Math', 'Error', 'Array'));
	2632	$text = $highlighter->parse_code();
	2633	$replaced = array();
	2634	if (preg_match_all('%[\w.$]+(?:\.(?:<span class="me\d+">)?[\w.$]+(?:</span>)?)+%', $text, $matches)) {
	2635	natcasesort(array_unique($matches[0]));
	2636	$matches = array_reverse($matches[0]);
	2637	foreach ($matches as $i => $match) {
	2638	$variable = preg_replace('%<[^>]+>%', '', $match);
	2639	if ($variables && $variables[$variable] && $variable != $exclude) {
	2640	$replaced[$i] = $match;
	2641	$text = str_replace($match, "%$i%", $text);
	2642	}
	2643	}
	2644	foreach ($matches as $i => $match) {
	2645	$variable = preg_replace('%<[^>]+>%', '', $match);
	2646	if ($variables && $variables[$variable]) {
	2647	$text = str_replace("%$i%", l($match, 'jsdoc/' . $version->title . '/' . $variable, array('style' => 'border-bottom: 1px dotted #ccc;'), NULL, NULL, FALSE, TRUE), $text);
	2648	}
	2649	}
	2650	}
	2651	if ($base && preg_match_all('%<span class="kw1">this</span>(\.(?:<span class="me\d+">[\w.$]+</span>)+)%', $text, $matches, PREG_SET_ORDER)) {
	2652	foreach ($matches as $match) {
	2653	$variable = $base . preg_replace('%<[^>]+>%', '', $match[1]);
	2654	if ($variables && $variables[$variable]) {
	2655	$version = node_load($variables[$variable]);
	2656	$text = str_replace($match[0], l($match[0], 'jsdoc/' . $version->title . '/' . $variable, array('style' => 'border-bottom: 1px dotted #ccc;'), NULL, NULL, FALSE, TRUE), $text);
	2657	}
	2658	}
	2659	}
	2660	return $text;
	2661	}
	2662
	2663	function _jsdoc_markup_text($text, $version, $exclude, $format = false){
	2664	if (!$format) {
	2665	$format = variable_get('jsdoc_input_format', 1);
	2666	}
	2667
	2668	$lines = array();
	2669	$tabbed = FALSE;
	2670	foreach (explode("\n", $text) as $line) {
	2671	if ($line{0} == "\t") {
	2672	if (!$tabbed) {
	2673	if (empty($lines)) {
	2674	$lines[] = "";
	2675	}
	2676	$lines[] = "";
	2677	}
	2678	$tabbed = TRUE;
	2679	}
	2680	else {
	2681	$tabbed = FALSE;
	2682	}
	2683	$lines[] = $line;
	2684	}
	2685	$text = implode("\n", $lines);
	2686
	2687	$tokens = array();
	2688	if (preg_match_all('%`([^`]+)`%', $text, $matches)) {
	2689	foreach (array_unique($matches[0]) as $i => $match) {
	2690	$code = substr($match, 1, -1);
	2691	$tokens[$i] = "<code>$code</code>";
	2692	$text = str_replace($match, "!$i!", $text);
	2693	}
	2694	}
	2695
	2696	$text = check_markup($text, $format, FALSE);
	2697
	2698	if (preg_match_all('%(?:\s(?:<pre>\|<code>)\s)+(.?)(?:\s(?:</pre>\|</code>)\s*)+%s', $text, $matches, PREG_SET_ORDER)) {
	2699	foreach ($matches as $match) {
	2700	$match[1] = str_replace('<', '<', str_replace('>', '>', $match[1]));
	2701	$text = str_replace($match[0], _jsdoc_markup_code($match[1], $version, $exclude), $text);
	2702	}
	2703	}
	2704
	2705	foreach ($tokens as $i => $token) {
	2706	$text = str_replace("!$i!", $token, $text);
	2707	}
	2708
	2709	return $text;
	2710	}
	2711
	2712	function _jsdoc_init() {
	2713	include_once(_jsdoc_get_base_path() . '/' . drupal_get_path('module', 'jsdoc') . '/lib/geshi/geshi.php');
	2714	drupal_add_css(drupal_get_path('module', 'jsdoc') . '/jsdoc.css');
	2715	}
	2716
	2717	// Theme functions
	2718	// ===============
	2719
	2720	/**
	2721	* When an object occurs in more than one file, we want
	2722	* to show this to the user so that they can choose
	2723	* the likely location until we disambiguate it.
	2724	*/
	2725	function theme_jsdoc_object_resources($node, $resources) {
	2726	$output = '<div class="jsdoc_object_resources">';
	2727	$output .= '<fieldset>';
	2728	$output .= '<legend>Appears in Resources</legend>';
	2729	$output .= '<div class="fieldset-wrapper">';
	2730	foreach ($resources as $resource) {
	2731	$output .= '<div class="form-item">';
	2732	$output .= $resource->href;
	2733	$output .= '</div>';
	2734	}
	2735	$output .= '</div>';
	2736	$output .= '</fieldset>';
	2737	$output .= '</div>';
	2738
	2739	return $output;
	2740	}
	2741
	2742	/**
	2743	* Theme the object type block.
	2744	*/
	2745	function theme_jsdoc_object_title($title) {
	2746	$output = implode('.', $title->crumbs);
	2747	if ($title->type) {
	2748	$output .= ': ' . $title->type->a;
	2749	}
	2750	return $output;
	2751	}
	2752
	2753	/**
	2754	* Theme the statement used to require this file
	2755	*/
	2756	function theme_jsdoc_object_require($require) {
	2757	return '<div class="form-item"><label>To Include:</label>include "' . $require . '";</div>';
	2758	}
	2759
	2760	/**
	2761	* Theme the location this file exists in
	2762	*/
	2763	function theme_jsdoc_object_resource($resource) {
	2764	return '<div class="form-item"><label>Found in:</label> ' . $resource . '</div>';
	2765	}
	2766
	2767	/**
	2768	* Theme the list of mixins for a given object
	2769	*/
	2770	function theme_jsdoc_object_mixins($mixins) {
	2771	$output = '<div class="form-item"><label>Mixins:</label>';
	2772	$counter = 0;
	2773	foreach ($mixins as $mixin) {
	2774	if ($mixin->in_prototype_chain) {
	2775	continue;
	2776	}
	2777	if ($counter) {
	2778	$output .= ', ';
	2779	}
	2780	if (!$mixin->from == 'normal') {
	2781	$output .= '[static] ';
	2782	}
	2783	$output .= l($mixin->node->title, $mixin->node->jsdoc_url);
	2784	if ($mixin->mixin_from) {
	2785	$output .= '<small> (from ' . $mixin->mixin_from . ')</small>';
	2786	}
	2787
	2788	++$counter;
	2789	}
	2790	if(!$counter){ $output .= 'None'; }
	2791	return $output . '</div>';
	2792	}
	2793
	2794	function theme_jsdoc_object_children($children) {
	2795	$output = '<div class="jsdoc_object_children">';
	2796	$output .= '<fieldset>';
	2797	$output .= '<legend>Fields</legend>';
	2798	$output .= '<div class="fieldset-wrapper">';
	2799
	2800	foreach ($children as $child) {
	2801	$output .= '<div class="form-item">';
	2802	$output .= l($child->title, $child->url);
	2803	if ($child->type && $key!='Functions' && $key!="Constructors") {
	2804	$output .= ': <small>' . $child->type->a . '</small> ';
	2805	}
	2806	if($child->signature){
	2807	$output .= $child->signature;
	2808	}
	2809	else if($key=="Functions"){
	2810	$output .= '() ';
	2811	}
	2812	if ($child->inheritance) {
	2813	$output .= ' <div><small>';
	2814	if ($child->override) {
	2815	$output .= ' Overrides ';
	2816	}
	2817	else {
	2818	$output .= ' Defined by ';
	2819	}
	2820	foreach ($child->inheritance as $i => $parent) {
	2821	if ($i) {
	2822	$output .= ', ';
	2823	}
	2824	$output .= l($parent->title, $parent->url);
	2825	}
	2826	$output .= '</small></div>';
	2827	}
	2828	if ($child->summary) {
	2829	$output .= '<div>' . str_replace("<", "<", str_replace(">", ">", $child->summary)) . '</div>';
	2830	}
	2831	$output .= '</div>';
	2832	}
	2833
	2834	$output .= '</div>';
	2835	$output .= '</fieldset>';
	2836	$output .= '</div>';
	2837
	2838	return $output;
	2839	}
	2840
	2841	/**
	2842	* Theme the prototype chain
	2843	*/
	2844	function theme_jsdoc_object_prototype_chain($chain) {
	2845	$output = '<div class="form-item"><label>Prototype Chain:</label>' ;
	2846	foreach ($chain as $i => $node) {
	2847	if ($i) {
	2848	$output .= ' » ';
	2849	}
	2850	$output .= l($node->title, $node->jsdoc_url);
	2851	}
	2852	return $output .= '</div>';
	2853	}
	2854
	2855	function theme_jsdoc_object_parent($node) {
	2856	return '<div class="form-item"><label>Parent Object:</label>' . $node->object_type_link . '</div>';
	2857	}
	2858
	2859	/**
	2860	* Theme the function signature and source.
	2861	*
	2862	* One of the things to note is that we pass fields
	2863	* because the constructor isn't always listed as the
	2864	* constructor because of the famous dojo.declare
	2865	*/
	2866	function theme_jsdoc_function_information($function, $fields, $obj) {
	2867	$output .= '<div class="jsdoc_function_information">';
	2868	$output .= '<fieldset class="collapsible">';
	2869	$output .= '<legend>' . 'Function Information' . '</legend>';
	2870	$output .= '<div class="fieldset-wrapper">';
	2871	$output .= '<div class="form-item">';
	2872	$output .= 'function ' . $function->signature;
	2873	$output .= '</div>';
	2874	$output .= '</div>';
	2875	$output .= '</fieldset>';
	2876	$output .= '</div>';
	2877
	2878	return $output;
	2879	}
	2880
	2881	function theme_jsdoc_function_parameters($parameters, $node) {
	2882	$output = '<div class="jsdoc_function_parameters">';
	2883	$output .= '<fieldset>';
	2884	$output .= '<legend>' . 'Parameters' . '</legend>';
	2885	$output .= '<div class="fieldset-wrapper">';
	2886	foreach ($parameters as $parameter) {
	2887	$output .= '<div class="form-item"><label>';
	2888	$types = array();
	2889	if ($parameter->types) {
	2890	foreach ($parameter->types as $type) {
	2891	$types[] = '<em>' . $type->a . '</em>';
	2892	}
	2893	}
	2894	if (count($types)) {
	2895	$output .= implode('\|', $types) . ' ';
	2896	}
	2897	$output .= $parameter->name;
	2898	$output .= '</label>';
	2899	$output .= $parameter->summary;
	2900	if (count($types) && $parameter->types[0]->fields) {
	2901	if ($parameter->summary && $parameter->types[0]->summary) {
	2902	$output .= '<br><br>';
	2903	}
	2904	$output .= $parameter->types[0]->summary;
	2905	if ($parameter->types[0]->summary) {
	2906	$output .= '<br>';
	2907	}
	2908	foreach ($parameter->types[0]->fields as $i => $field) {
	2909	$output .= '<br>';
	2910
	2911	$field_types = array();
	2912	$repeating = false;
	2913	$optional = false;
	2914	if ($field->types) {
	2915	foreach ($field->types as $type) {
	2916	if ($type->repeating) {
	2917	$repeating = true;
	2918	}
	2919	if ($type->optional) {
	2920	$optional = true;
	2921	}
	2922	$field_types[] = '<em>' . $type->a . '</em>';
	2923	}
	2924	}
	2925
	2926	$output .= '    ';
	2927	if (count($field_types)) {
	2928	$output .= implode('\|', $field_types) . ' ';
	2929	}
	2930	$output .= $field->a;
	2931	if ($repeating) {
	2932	$output .= ' <small><em>repeating</em></small>';
	2933	}
	2934	if ($optional) {
	2935	$output .= ' <small><em>optional</em></small>';
	2936	}
	2937	if ($field->summary) {
	2938	$output .= ': ' . $field->summary;
	2939	}
	2940	}
	2941	}
	2942	$output .= '</div>';
	2943	}
	2944	$output .= '</div>';
	2945	$output .= '</fieldset>';
	2946	$output .= '</div>';
	2947
	2948	return $output;
	2949	}
	2950
	2951	function theme_jsdoc_object_summary($summary) {
	2952	return '';
	2953	}
	2954
	2955	function theme_jsdoc_object_description($summary, $description) {
	2956	return $summary . $description;
	2957	}
	2958
	2959	function theme_jsdoc_object_example($example, $weight) {
	2960	return '<div class="form-item"><label>Example #' . $weight . '</label>' . $example . '</div>';
	2961	}
	2962
	2963	function theme_jsdoc_object_examples($examples) {
	2964	$output = '<div class="jsdoc_object_examples">';
	2965	$output .= '<fieldset>';
	2966	$output .= '<legend>Examples</legend>';
	2967	$output .= '<div class="fieldset-wrapper">';
	2968	$output .= implode('', $examples);
	2969	$output .= '</div></fieldset></div>';
	2970	return $output;
	2971	}
	2972
	2973	function theme_jsdoc_search($name) {
	2974	return '<div class="form-item"><input class="form-text" name="' . $name . '" /> <input class="form-submit" type="submit" name="op" value="Go" /></div>';
	2975	}
	2976
	2977	function theme_jsdoc_namespaces($namespaces, $version) {
	2978	$output = '<ul>';
	2979	foreach ($namespaces as $namespace) {
	2980	$output .= "<li>{$namespace->a}";
	2981	if (!empty($namespace->children)) {
	2982	$output .= '<ul>';
	2983	foreach ($namespace->children as $child) {
	2984	$output .= "<li>{$child->a}</li>";
	2985	}
	2986	$output .= '</ul>';
	2987	}
	2988	$output .= "</li>";
	2989	}
	2990	$output .= '</ul>';
	2991	return $output;
	2992	}
	2993
	2994	function theme_jsdoc_resource_source_link($project, $resource) {
	2995	return $resource;
	2996	}
	2997
	2998	function theme_jsdoc_resolve_constructor($objects) {
	2999	}
	3000
	3001	function theme_jsdoc_ide($content){
	3002	return theme('page', $content);
	3003	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format