You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

945 lines
33 KiB

4 years ago
4 years ago
6 years ago
  1. <?php
  2. namespace p3k\XRay\Formats;
  3. class Mf2 extends Format {
  4. use Mf2Feed;
  5. public static function matches_host($url) {
  6. return true;
  7. }
  8. public static function matches($url) {
  9. return true;
  10. }
  11. public static function parse($http_response, $http, $opts=[]) {
  12. $mf2 = $http_response['body'];
  13. $url = $http_response['url'];
  14. if(!isset($mf2['items']) || count($mf2['items']) == 0)
  15. return false;
  16. // If they are expecting a feed, always return a feed or an error
  17. if(isset($opts['expect']) && $opts['expect'] == 'feed') {
  18. return self::parseAsHFeed($mf2, $http, $url);
  19. }
  20. // Remove h-breadcrumb since we never use it and it causes problems determining
  21. // whether a page is a feed or permalink
  22. $mf2['items'] = array_values(array_filter($mf2['items'], function($item){
  23. return !in_array('h-breadcrumb', $item['type']);
  24. }));
  25. $items = $mf2['items'];
  26. // If there is more than one item on the page, it may be a feed.
  27. // Remove an h-card if there is one that doesn't match the page URL, then try again.
  28. // (Don't modify the actual tree, but compare on the modified tree)
  29. if(count($items) > 1) {
  30. $tmpmf2 = array_filter($items, function($item) use($url){
  31. return !(in_array('h-card', $item['type']) && isset($item['properties']['url'][0]) && $item['properties']['url'][0] != $url);
  32. });
  33. $items = array_values($tmpmf2);
  34. }
  35. // If there is only one item left on the page, it's a permalink, and just use that
  36. if(count($items) == 1) {
  37. $item = $items[0];
  38. if(in_array('h-entry', $item['type']) || in_array('h-cite', $item['type'])) {
  39. #Parse::debug("mf2:0: Recognized $url as an h-entry it is the only item on the page");
  40. return self::parseAsHEntry($mf2, $item, $http, $url);
  41. }
  42. if(in_array('h-event', $item['type'])) {
  43. #Parse::debug("mf2:0: Recognized $url as an h-event it is the only item on the page");
  44. return self::parseAsHEvent($mf2, $item, $http, $url);
  45. }
  46. if(in_array('h-review', $item['type'])) {
  47. #Parse::debug("mf2:0: Recognized $url as an h-review it is the only item on the page");
  48. return self::parseAsHReview($mf2, $item, $http, $url);
  49. }
  50. if(in_array('h-recipe', $item['type'])) {
  51. #Parse::debug("mf2:0: Recognized $url as an h-recipe it is the only item on the page");
  52. return self::parseAsHRecipe($mf2, $item, $http, $url);
  53. }
  54. if(in_array('h-product', $item['type'])) {
  55. #Parse::debug("mf2:0: Recognized $url as an h-product it is the only item on the page");
  56. return self::parseAsHProduct($mf2, $item, $http, $url);
  57. }
  58. if(in_array('h-item', $item['type'])) {
  59. #Parse::debug("mf2:0: Recognized $url as an h-product it is the only item on the page");
  60. return self::parseAsHItem($mf2, $item, $http, $url);
  61. }
  62. if(in_array('h-card', $item['type'])) {
  63. #Parse::debug("mf2:0: Recognized $url as an h-card it is the only item on the page");
  64. return self::parseAsHCard($item, $http, $url, $url);
  65. }
  66. if(in_array('h-app', $item['type']) || in_array('h-x-app', $item['type'])) {
  67. #Parse::debug("mf2:0: Recognized $url as an h-feed because it is the only item on the page");
  68. return self::parseAsHApp($mf2, $item, $http, $url);
  69. }
  70. if(in_array('h-feed', $item['type'])) {
  71. #Parse::debug("mf2:0: Recognized $url as an h-feed because it is the only item on the page");
  72. return self::parseAsHFeed($mf2, $http, $url);
  73. }
  74. }
  75. // Check the list of items on the page to see if one matches the URL of the page,
  76. // and treat as a permalink for that object if so.
  77. foreach($mf2['items'] as $item) {
  78. if(array_key_exists('url', $item['properties'])) {
  79. $urls = $item['properties']['url'];
  80. $urls = array_map('\p3k\XRay\normalize_url', $urls);
  81. if(in_array($url, $urls)) {
  82. #Parse::debug("mf2:1: Recognized $url as a permalink because an object on the page matched the URL of the request");
  83. if(in_array('h-card', $item['type'])) {
  84. return self::parseAsHCard($item, $http, $url, $url);
  85. } elseif(in_array('h-entry', $item['type']) || in_array('h-cite', $item['type'])) {
  86. return self::parseAsHEntry($mf2, $item, $http, $url);
  87. } elseif(in_array('h-event', $item['type'])) {
  88. return self::parseAsHEvent($mf2, $item, $http, $url);
  89. } elseif(in_array('h-review', $item['type'])) {
  90. return self::parseAsHReview($mf2, $item, $http, $url);
  91. } elseif(in_array('h-recipe', $item['type'])) {
  92. return self::parseAsHRecipe($mf2, $item, $http, $url);
  93. } elseif(in_array('h-product', $item['type'])) {
  94. return self::parseAsHProduct($mf2, $item, $http, $url);
  95. } elseif(in_array('h-item', $item['type'])) {
  96. return self::parseAsHItem($mf2, $item, $http, $url);
  97. } elseif(in_array('h-app', $item['type']) || in_array('h-x-app', $item['type'])) {
  98. return self::parseAsHApp($mf2, $item, $http, $url);
  99. } elseif(in_array('h-feed', $item['type'])) {
  100. return self::parseAsHFeed($mf2, $http, $url);
  101. } else {
  102. #Parse::debug('This object was not a recognized type.');
  103. return false;
  104. }
  105. }
  106. }
  107. }
  108. // Check for an h-card matching rel=author or the author URL of any h-* on the page,
  109. // and return the h-* object if so
  110. if(isset($mf2['rels']['author'])) {
  111. foreach($mf2['items'] as $card) {
  112. if(in_array('h-card', $card['type']) && array_key_exists('url', $card['properties'])) {
  113. $urls = \p3k\XRay\normalize_urls($card['properties']['url']);
  114. if(count(array_intersect($urls, \p3k\XRay\normalize_urls($mf2['rels']['author']))) > 0) {
  115. // There is an author h-card on this page
  116. // Now look for the first h-* object other than an h-card and use that as the object
  117. foreach($mf2['items'] as $item) {
  118. if(!in_array('h-card', $item['type'])) {
  119. if(in_array('h-entry', $item['type']) || in_array('h-cite', $item['type'])) {
  120. return self::parseAsHEntry($mf2, $item, $http, $url);
  121. } elseif(in_array('h-event', $item['type'])) {
  122. return self::parseAsHEvent($mf2, $item, $http, $url);
  123. } elseif(in_array('h-review', $item['type'])) {
  124. return self::parseAsHReview($mf2, $item, $http, $url);
  125. } elseif(in_array('h-recipe', $item['type'])) {
  126. return self::parseAsHRecipe($mf2, $item, $http, $url);
  127. } elseif(in_array('h-product', $item['type'])) {
  128. return self::parseAsHProduct($mf2, $item, $http, $url);
  129. } elseif(in_array('h-item', $item['type'])) {
  130. return self::parseAsHItem($mf2, $item, $http, $url);
  131. } elseif(in_array('h-app', $item['type']) || in_array('h-x-app', $item['type'])) {
  132. return self::parseAsHApp($mf2, $item, $http, $url);
  133. }
  134. }
  135. }
  136. }
  137. }
  138. }
  139. }
  140. // At this point, if there are any h-entrys left on the page, it's probably a feed.
  141. if(count($items) > 0) {
  142. if(count(array_filter($items, function($item){
  143. return in_array('h-entry', $item['type']);
  144. })) > 0) {
  145. #Parse::debug("mf2:2: Recognized $url as an h-feed because there are more than one object on the page");
  146. return self::parseAsHFeed($mf2, $http, $url);
  147. }
  148. }
  149. // If the first item is an h-feed, parse as a feed
  150. $first = $items[0];
  151. if(in_array('h-feed', $first['type'])) {
  152. #Parse::debug("mf2:3: Recognized $url as an h-feed because the first item is an h-feed");
  153. return self::parseAsHFeed($mf2, $http, $url);
  154. }
  155. // Fallback case, but hopefully we have found something before this point
  156. foreach($mf2['items'] as $item) {
  157. // Otherwise check for a recognized h-* object
  158. if(in_array('h-entry', $item['type']) || in_array('h-cite', $item['type'])) {
  159. #Parse::debug("mf2:6: $url is falling back to the first h-entry on the page");
  160. return self::parseAsHEntry($mf2, $item, $http, $url);
  161. } elseif(in_array('h-event', $item['type'])) {
  162. #Parse::debug("mf2:6: $url is falling back to the first h-event on the page");
  163. return self::parseAsHEvent($mf2, $item, $http, $url);
  164. } elseif(in_array('h-review', $item['type'])) {
  165. #Parse::debug("mf2:6: $url is falling back to the first h-review on the page");
  166. return self::parseAsHReview($mf2, $item, $http, $url);
  167. } elseif(in_array('h-recipe', $item['type'])) {
  168. #Parse::debug("mf2:6: $url is falling back to the first h-recipe on the page");
  169. return self::parseAsHRecipe($mf2, $item, $http, $url);
  170. } elseif(in_array('h-product', $item['type'])) {
  171. #Parse::debug("mf2:6: $url is falling back to the first h-product on the page");
  172. return self::parseAsHProduct($mf2, $item, $http, $url);
  173. } elseif(in_array('h-item', $item['type'])) {
  174. #Parse::debug("mf2:6: $url is falling back to the first h-item on the page");
  175. return self::parseAsHItem($mf2, $item, $http, $url);
  176. } elseif(in_array('h-app', $item['type']) || in_array('h-x-app', $item['type'])) {
  177. #Parse::debug("mf2:6: $url is falling back to the first h-item on the page");
  178. return self::parseAsHApp($mf2, $item, $http, $url);
  179. }
  180. }
  181. #Parse::debug("mf2:E: No object at $url was recognized");
  182. return false;
  183. }
  184. private static function collectSingleValues($properties, $urlProperties, $item, $url, &$data) {
  185. foreach($properties as $p) {
  186. if(($v = self::getPlaintext($item, $p)) !== null) {
  187. $data[$p] = $v;
  188. }
  189. }
  190. foreach($urlProperties as $p) {
  191. if($p == 'url') {
  192. // Special handling for the 'url' property to prioritize finding the URL on the same domain
  193. if($values = self::getPlaintextValues($item, 'url')) {
  194. if(count($values) == 1) {
  195. if(self::isURL($values[0]))
  196. $data['url'] = $values[0];
  197. }
  198. else {
  199. $set = false;
  200. foreach($values as $v) {
  201. if(self::isURL($v) && parse_url($v, PHP_URL_HOST) == parse_url($url, PHP_URL_HOST)) {
  202. $set = true;
  203. $data['url'] = $v;
  204. }
  205. }
  206. if(!$set) {
  207. // Fall back to the first URL if there isn't one on the domain
  208. if(self::isURL($values[0]))
  209. $data['url'] = $values[0];
  210. }
  211. }
  212. }
  213. } else {
  214. if(($v = self::getPlaintext($item, $p)) !== null) {
  215. if(self::isURL($v))
  216. $data[$p] = $v;
  217. }
  218. }
  219. }
  220. }
  221. private static function parseHTMLValue($property, $item) {
  222. if(!array_key_exists($property, $item['properties']))
  223. return null;
  224. $textContent = false;
  225. $htmlContent = false;
  226. $content = $item['properties'][$property][0];
  227. if(is_string($content)) {
  228. $textContent = $content;
  229. } elseif(!is_string($content) && is_array($content) && array_key_exists('html', $content)) {
  230. if(array_key_exists('html', $content)) {
  231. // Only allow images in the content if there is no photo property set
  232. if(isset($item['properties']['photo']))
  233. $allowImg = false;
  234. else
  235. $allowImg = true;
  236. $htmlContent = trim(self::sanitizeHTML($content['html'], $allowImg));
  237. #$textContent = trim(str_replace("&#xD;","\r",$content['value']));
  238. $textContent = trim(self::stripHTML($htmlContent));
  239. } else {
  240. if(isset($content['value']))
  241. $textContent = trim($content['value']);
  242. }
  243. }
  244. if($textContent || $htmlContent) {
  245. $data = [
  246. 'text' => $textContent
  247. ];
  248. // Only add HTML content if there is actual content.
  249. // If the text content ends up empty, then the HTML should be too
  250. // e.g. <div class="e-content"><a href=""><img src="" class="u-photo"></a></div>
  251. // should not return content of <a href=""></a>
  252. // TODO: still need to remove empty <a> tags when there is other text in the content
  253. if($htmlContent && $textContent && $textContent != $htmlContent) {
  254. $data['html'] = $htmlContent;
  255. }
  256. // Also add HTML content if it contains images, video or audio
  257. // TODO: allow video and audio tags in content, then uncomment this
  258. if(strpos($htmlContent, '<img') !== false
  259. /* || strpos($htmlContent, '<video') !== false */
  260. /* || strpos($htmlContent, '<audio') !== false */) {
  261. $data['html'] = $htmlContent;
  262. }
  263. if(!$data['text'] && !isset($data['html']))
  264. return null;
  265. return $data;
  266. } else {
  267. return null;
  268. }
  269. }
  270. // Always return arrays, and may contain plaintext content
  271. // Nested objects are added to refs and the URL is used as the value if present
  272. private static function collectArrayValues($properties, $item, &$data, &$refs, &$http) {
  273. foreach($properties as $p) {
  274. if(array_key_exists($p, $item['properties'])) {
  275. foreach($item['properties'][$p] as $v) {
  276. if(is_string($v)) {
  277. if(!array_key_exists($p, $data)) $data[$p] = [];
  278. if(!in_array($v, $data[$p]))
  279. $data[$p][] = $v;
  280. } elseif(self::isMicroformat($v)) {
  281. if(($u=self::getPlaintext($v, 'url')) && self::isURL($u)) {
  282. if(!array_key_exists($p, $data)) $data[$p] = [];
  283. if(!in_array($u, $data[$p]))
  284. $data[$p][] = $u;
  285. $ref = self::parse([
  286. 'body' => ['items'=>[$v]],
  287. 'url' => $u,
  288. 'code' => null,
  289. ], $http);
  290. if($ref) {
  291. $refs[$u] = $ref['data'];
  292. }
  293. } else {
  294. if(!array_key_exists($p, $data)) $data[$p] = [];
  295. if(!in_array($v['value'], $data[$p]))
  296. $data[$p][] = $v['value'];
  297. }
  298. }
  299. }
  300. }
  301. }
  302. }
  303. private static function parseEmbeddedHCard($property, $item, &$http) {
  304. if(array_key_exists($property, $item['properties'])) {
  305. $mf2 = $item['properties'][$property][0];
  306. if(is_string($mf2) && self::isURL($mf2)) {
  307. $hcard = [
  308. 'type' => 'card',
  309. 'url' => $mf2
  310. ];
  311. return $hcard;
  312. } if(self::isMicroformat($mf2) && in_array('h-card', $mf2['type'])) {
  313. $hcard = [
  314. 'type' => 'card',
  315. ];
  316. $properties = ['name','latitude','longitude','locality','region','country','url'];
  317. foreach($properties as $p) {
  318. if($v=self::getPlaintext($mf2, $p)) {
  319. $hcard[$p] = $v;
  320. }
  321. }
  322. return $hcard;
  323. }
  324. }
  325. return false;
  326. }
  327. private static function collectArrayURLValues($properties, $item, &$data, &$refs, &$http) {
  328. $keys = [];
  329. foreach($properties as $p) {
  330. if(array_key_exists($p, $item['properties'])) {
  331. foreach($item['properties'][$p] as $v) {
  332. if(is_string($v) && self::isURL($v)) {
  333. if(!array_key_exists($p, $data)) $data[$p] = [];
  334. $data[$p][] = $v;
  335. $keys[] = $p;
  336. }
  337. elseif(self::isMicroformat($v) && ($u=self::getPlaintext($v, 'url')) && self::isURL($u)) {
  338. if(!array_key_exists($p, $data)) $data[$p] = [];
  339. $data[$p][] = $u;
  340. $keys[] = $p;
  341. // parse the object and put the result in the "refs" object
  342. $ref = self::parse([
  343. 'body' => ['items'=>[$v]],
  344. 'url' => $u,
  345. 'code' => null,
  346. ], $http);
  347. if($ref) {
  348. $refs[$u] = $ref['data'];
  349. }
  350. }
  351. }
  352. }
  353. }
  354. // Remove duplicate values
  355. foreach(array_unique($keys) as $key) {
  356. $data[$key] = array_unique($data[$key]);
  357. }
  358. }
  359. private static function determineNameAndContent($item, &$data) {
  360. // Determine if the name is distinct from the content
  361. $name = self::getPlaintext($item, 'name');
  362. $textContent = null;
  363. $htmlContent = null;
  364. $content = self::getHTMLValue($item, 'content');
  365. if(is_string($content)) {
  366. $textContent = $content;
  367. } elseif($content) {
  368. $htmlContent = array_key_exists('html', $content) ? $content['html'] : null;
  369. $textContent = array_key_exists('value', $content) ? $content['value'] : null;
  370. }
  371. $checkedname = $name;
  372. if($content) {
  373. // Trim ellipses from the name
  374. $name = preg_replace('/ ?(\.\.\.|…)$/', '', $name);
  375. // Remove all whitespace when checking equality
  376. $nameCompare = preg_replace('/\s/','',trim($name));
  377. $contentCompare = preg_replace('/\s/','',trim($textContent));
  378. // Check if the name is a prefix of the content
  379. if($contentCompare && $nameCompare && strpos($contentCompare, $nameCompare) === 0) {
  380. $checkedname = null;
  381. }
  382. }
  383. if($checkedname) {
  384. $data['name'] = $checkedname;
  385. }
  386. // If there is content, always return the plaintext content, and return HTML content if it's different
  387. if($content) {
  388. $content = self::parseHTMLValue('content', $item);
  389. if($content['text'] || $content['html']) {
  390. $data['content']['text'] = $content['text'];
  391. if(isset($content['html']))
  392. $data['content']['html'] = $content['html'];
  393. } else {
  394. // If the content text was blank because the img was removed and that was the only content,
  395. // then put the name back as the name if it was previously set.
  396. // See https://github.com/aaronpk/XRay/issues/57
  397. if($name) {
  398. $data['name'] = $name;
  399. }
  400. }
  401. }
  402. }
  403. private static function parseAsHEntry($mf2, $item, $http, $url) {
  404. $data = [
  405. 'type' => 'entry'
  406. ];
  407. $refs = [];
  408. // Single plaintext and URL values
  409. self::collectSingleValues(['published','summary','rsvp','swarm-coins'], ['url','featured','follow-of'], $item, $url, $data);
  410. if(isset($data['rsvp']))
  411. $data['rsvp'] = strtolower($data['rsvp']);
  412. // These properties are always returned as arrays and may contain plaintext content
  413. // First strip leading hashtags from category values if present
  414. if(array_key_exists('category', $item['properties'])) {
  415. foreach($item['properties']['category'] as $i=>$c) {
  416. if(is_string($c))
  417. $item['properties']['category'][$i] = ltrim($c, '#');
  418. }
  419. }
  420. self::collectArrayValues(['category','invitee'], $item, $data, $refs, $http);
  421. // These properties are always returned as arrays and always URLs
  422. // If the value is an h-* object with a URL, the URL is used and a "ref" is added as well
  423. self::collectArrayURLValues(['photo','video','audio','syndication','in-reply-to','like-of','repost-of','bookmark-of','quotation-of'], $item, $data, $refs, $http);
  424. // Hack to make quotation-of a single value
  425. if(isset($data['quotation-of']))
  426. $data['quotation-of'] = $data['quotation-of'][0];
  427. self::determineNameAndContent($item, $data);
  428. if($author = self::findAuthor($mf2, $item, $http, $url))
  429. $data['author'] = $author;
  430. if($checkin = self::parseEmbeddedHCard('checkin', $item, $http))
  431. $data['checkin'] = $checkin;
  432. $data['post-type'] = \p3k\XRay\PostType::discover($data);
  433. $response = [
  434. 'data' => $data,
  435. ];
  436. if(count($refs)) {
  437. $response['data']['refs'] = $refs;
  438. }
  439. return $response;
  440. }
  441. private static function parseAsHReview($mf2, $item, $http, $url) {
  442. $data = [
  443. 'type' => 'review'
  444. ];
  445. $refs = [];
  446. self::collectSingleValues(['summary','published','rating','best','worst'], ['url'], $item, $url, $data);
  447. // Fallback for Mf1 "description" as content. The PHP parser does not properly map this to "content"
  448. $description = self::parseHTMLValue('description', $item);
  449. if($description) {
  450. $data['content'] = $description;
  451. }
  452. self::collectArrayValues(['category'], $item, $data, $refs, $http);
  453. self::collectArrayURLValues(['item'], $item, $data, $refs, $http);
  454. self::determineNameAndContent($item, $data);
  455. if($author = self::findAuthor($mf2, $item, $http, $url))
  456. $data['author'] = $author;
  457. $data['post-type'] = \p3k\XRay\PostType::discover($data);
  458. $response = [
  459. 'data' => $data
  460. ];
  461. if(count($refs)) {
  462. $response['data']['refs'] = $refs;
  463. }
  464. return $response;
  465. }
  466. private static function parseAsHRecipe($mf2, $item, $http, $url) {
  467. $data = [
  468. 'type' => 'recipe',
  469. ];
  470. $refs = [];
  471. self::collectSingleValues(['name','summary','published','duration','yield','nutrition'], ['url'], $item, $url, $data);
  472. $instructions = self::parseHTMLValue('instructions', $item);
  473. if($instructions) {
  474. $data['instructions'] = $instructions;
  475. }
  476. self::collectArrayValues(['category','ingredient'], $item, $data, $refs, $http);
  477. self::collectArrayURLValues(['photo'], $item, $data, $refs, $http);
  478. if($author = self::findAuthor($mf2, $item, $http, $url))
  479. $data['author'] = $author;
  480. $data['post-type'] = \p3k\XRay\PostType::discover($data);
  481. $response = [
  482. 'data' => $data
  483. ];
  484. if(count($refs)) {
  485. $response['data']['refs'] = $refs;
  486. }
  487. return $response;
  488. }
  489. private static function parseAsHProduct($mf2, $item, $http, $url) {
  490. $data = [
  491. 'type' => 'product'
  492. ];
  493. $refs = [];
  494. self::collectSingleValues(['name','identifier','price'], ['url'], $item, $url, $data);
  495. $description = self::parseHTMLValue('description', $item);
  496. if($description) {
  497. $data['description'] = $description;
  498. }
  499. self::collectArrayValues(['category','brand'], $item, $data, $refs, $http);
  500. self::collectArrayURLValues(['photo','video','audio'], $item, $data, $refs, $http);
  501. $response = [
  502. 'data' => $data
  503. ];
  504. if(count($refs)) {
  505. $response['data']['refs'] = $refs;
  506. }
  507. return $response;
  508. }
  509. private static function parseAsHItem($mf2, $item, $http, $url) {
  510. $data = [
  511. 'type' => 'item'
  512. ];
  513. $refs = [];
  514. self::collectSingleValues(['name'], ['url'], $item, $url, $data);
  515. self::collectArrayURLValues(['photo','video','audio'], $item, $data, $refs, $http);
  516. $response = [
  517. 'data' => $data
  518. ];
  519. if(count($refs)) {
  520. $response['data']['refs'] = $refs;
  521. }
  522. return $response;
  523. }
  524. private static function parseAsHApp($mf2, $item, $http, $url) {
  525. $data = [
  526. 'type' => 'app'
  527. ];
  528. self::collectSingleValues(['name'], ['url','logo'], $item, $url, $data);
  529. self::collectArrayURLValues(['redirect-uri'], $item, $data, $refs, $http);
  530. if(!isset($data['url']))
  531. $data['url'] = $url;
  532. if(isset($mf2['rels']['redirect_uri'])) {
  533. if(!isset($data['redirect-uri'])) $data['redirect-uri'] = [];
  534. $data['redirect-uri'] = array_merge($data['redirect-uri'], $mf2['rels']['redirect_uri']);
  535. }
  536. if(isset($data['redirect-uri'])) {
  537. $data['redirect-uri'] = array_values(array_unique($data['redirect-uri']));
  538. }
  539. $response = [
  540. 'data' => $data
  541. ];
  542. return $response;
  543. }
  544. private static function parseAsHEvent($mf2, $item, $http, $url) {
  545. $data = [
  546. 'type' => 'event'
  547. ];
  548. $refs = [];
  549. // Single plaintext and URL values
  550. self::collectSingleValues(['name','summary','published','start','end','duration'], ['url','featured'], $item, $url, $data);
  551. // These properties are always returned as arrays and may contain plaintext content
  552. self::collectArrayValues(['category','location','attendee'], $item, $data, $refs, $http);
  553. // These properties are always returned as arrays and always URLs
  554. // If the value is an h-* object with a URL, the URL is used and a "ref" is added as well
  555. self::collectArrayURLValues(['photo','video','audio','syndication'], $item, $data, $refs, $http);
  556. // If there is a description, always return the plaintext content, and return HTML content if it's different
  557. $content = self::parseHTMLValue('content', $item);
  558. if($content) {
  559. $data['content'] = $content;
  560. } else {
  561. // Fall back to looking for "description"
  562. $content = self::parseHTMLValue('description', $item);
  563. if($content)
  564. $data['content'] = $content;
  565. }
  566. if($author = self::findAuthor($mf2, $item, $http, $url))
  567. $data['author'] = $author;
  568. $data['post-type'] = \p3k\XRay\PostType::discover($data);
  569. $response = [
  570. 'data' => $data
  571. ];
  572. if(count($refs)) {
  573. $response['data']['refs'] = $refs;
  574. }
  575. return $response;
  576. }
  577. private static function parseAsHCard($item, $http, $url, $authorURL=false) {
  578. $data = [
  579. 'type' => 'card',
  580. 'name' => null,
  581. 'url' => null,
  582. 'photo' => null
  583. ];
  584. $properties = ['url','name','photo'];
  585. foreach($properties as $p) {
  586. if($p == 'url' && $authorURL) {
  587. // If there is a matching author URL, use that one
  588. $found = false;
  589. foreach($item['properties']['url'] as $url) {
  590. if(self::isURL($url)) {
  591. $url = \p3k\XRay\normalize_url($url);
  592. if($url == \p3k\XRay\normalize_url($authorURL)) {
  593. $data['url'] = $url;
  594. $found = true;
  595. }
  596. }
  597. }
  598. if(!$found && self::isURL($item['properties']['url'][0])) {
  599. $data['url'] = $item['properties']['url'][0];
  600. }
  601. } else if(($v = self::getPlaintext($item, $p)) !== null) {
  602. // Make sure the URL property is actually a URL
  603. if($p == 'url' || $p == 'photo') {
  604. if(self::isURL($v))
  605. $data[$p] = $v;
  606. } else {
  607. $data[$p] = $v;
  608. }
  609. }
  610. }
  611. // If no URL property was found, use the $authorURL provided
  612. if(!$data['url'])
  613. $data['url'] = $authorURL;
  614. $response = [
  615. 'data' => $data
  616. ];
  617. return $response;
  618. }
  619. private static function findAuthor($mf2, $item, $http, $url) {
  620. $author = [
  621. 'type' => 'card',
  622. 'name' => null,
  623. 'url' => null,
  624. 'photo' => null
  625. ];
  626. // Author Discovery
  627. // http://indiewebcamp.com/authorship
  628. $authorPage = false;
  629. if(array_key_exists('author', $item['properties'])) {
  630. // Check if any of the values of the author property are an h-card
  631. foreach($item['properties']['author'] as $a) {
  632. if(self::isHCard($a)) {
  633. // 5.1 "if it has an h-card, use it, exit."
  634. return self::parseAsHCard($a, $http, $url)['data'];
  635. } elseif(is_string($a)) {
  636. if(self::isURL($a)) {
  637. // 5.2 "otherwise if author property is an http(s) URL, let the author-page have that URL"
  638. $authorPage = $a;
  639. } else {
  640. // 5.3 "otherwise use the author property as the author name, exit"
  641. // We can only set the name, no h-card or URL was found
  642. $author['name'] = self::getPlaintext($item, 'author');
  643. return $author;
  644. }
  645. } else {
  646. // This case is only hit when the author property is an mf2 object that is not an h-card
  647. $author['name'] = self::getPlaintext($item, 'author');
  648. return $author;
  649. }
  650. }
  651. }
  652. // 6. "if no author page was found" ... check for rel-author link
  653. if(!$authorPage) {
  654. if(isset($mf2['rels']) && isset($mf2['rels']['author']))
  655. $authorPage = $mf2['rels']['author'][0];
  656. }
  657. // 7. "if there is an author-page URL" ...
  658. if($authorPage) {
  659. // 7.1 "get the author-page from that URL and parse it for microformats2"
  660. $authorPageContents = self::getURL($authorPage, $http);
  661. if($authorPageContents) {
  662. foreach($authorPageContents['items'] as $i) {
  663. if(self::isHCard($i)) {
  664. // 7.2 "if author-page has 1+ h-card with url == uid == author-page's URL, then use first such h-card, exit."
  665. if(array_key_exists('url', $i['properties'])
  666. and in_array(\p3k\XRay\normalize_url($authorPage), \p3k\XRay\normalize_urls($i['properties']['url']))
  667. and array_key_exists('uid', $i['properties'])
  668. and in_array(\p3k\XRay\normalize_url($authorPage), \p3k\XRay\normalize_urls($i['properties']['uid']))
  669. ) {
  670. return self::parseAsHCard($i, $http, $url, $authorPage)['data'];
  671. }
  672. // 7.3 "else if author-page has 1+ h-card with url property which matches the href of a rel-me link on the author-page"
  673. $relMeLinks = (isset($authorPageContents['rels']) && isset($authorPageContents['rels']['me'])) ? $authorPageContents['rels']['me'] : [];
  674. if(count($relMeLinks) > 0
  675. and array_key_exists('url', $i['properties'])
  676. and count(array_intersect(\p3k\XRay\normalize_urls($i['properties']['url']), \p3k\XRay\normalize_urls($relMeLinks))) > 0
  677. ) {
  678. return self::parseAsHCard($i, $http, $url, $authorPage)['data'];
  679. }
  680. }
  681. }
  682. }
  683. // 7.4 "if the h-entry's page has 1+ h-card with url == author-page URL, use first such h-card, exit."
  684. foreach($mf2['items'] as $i) {
  685. if(self::isHCard($i)) {
  686. if(array_key_exists('url', $i['properties'])
  687. and in_array(\p3k\XRay\normalize_url($authorPage), \p3k\XRay\normalize_urls($i['properties']['url']))
  688. ) {
  689. return self::parseAsHCard($i, $http, $url)['data'];
  690. }
  691. }
  692. // Also check the "author" property
  693. // (for finding the author of an h-feed's children when the author is the p-author property of the h-feed)
  694. if(isset($i['properties']['author'])) {
  695. foreach($i['properties']['author'] as $ic) {
  696. if(self::isHCard($ic)) {
  697. if(array_key_exists('url', $ic['properties'])
  698. and in_array(\p3k\XRay\normalize_url($authorPage), \p3k\XRay\normalize_urls($ic['properties']['url']))
  699. ) {
  700. return self::parseAsHCard($ic, $http, $url)['data'];
  701. }
  702. }
  703. }
  704. }
  705. }
  706. }
  707. // The below is not yet in the authorship algorithm.
  708. // If the top object is an h-feed, check for an author property there
  709. if(isset($mf2['items'][0]['type'][0]) && in_array('h-feed', $mf2['items'][0]['type'])) {
  710. if(isset($mf2['items'][0]['properties']['author'][0])) {
  711. $potentialAuthor = $mf2['items'][0]['properties']['author'][0];
  712. if(is_array($potentialAuthor['type']) && in_array('h-card', $potentialAuthor['type'])) {
  713. return self::parseAsHCard($potentialAuthor, $http, $url)['data'];
  714. }
  715. }
  716. }
  717. // If still no author is found, and this page is a feed (list of h-*),
  718. // then use the first h-card in the list of items.
  719. $items = array_filter($mf2['items'], function($item){
  720. return !in_array('h-card', $item['type']);
  721. });
  722. if(count($items) > 1) {
  723. $card = self::_findFirstOfType($mf2, 'h-card');
  724. if($card) {
  725. return self::parseAsHCard($card, $http, $url)['data'];
  726. }
  727. }
  728. if(!$author['name'] && !$author['photo'] && !$author['url'])
  729. return null;
  730. return $author;
  731. }
  732. private static function hasNumericKeys(array $arr) {
  733. foreach($arr as $key=>$val)
  734. if (is_numeric($key))
  735. return true;
  736. return false;
  737. }
  738. private static function isMicroformat($mf) {
  739. return is_array($mf)
  740. and !self::hasNumericKeys($mf)
  741. and !empty($mf['type'])
  742. and isset($mf['properties']);
  743. }
  744. private static function isHCard($mf) {
  745. return is_array($mf)
  746. and !empty($mf['type'])
  747. and is_array($mf['type'])
  748. and in_array('h-card', $mf['type']);
  749. }
  750. private static function isURL($string) {
  751. return preg_match('/^https?:\/\/.+\..+$/', $string);
  752. }
  753. // Given an array of microformats properties and a key name, return the plaintext value
  754. // at that property
  755. // e.g.
  756. // {"properties":{"published":["foo"]}} results in "foo"
  757. private static function getPlaintext($mf2, $k, $fallback=null) {
  758. if(!empty($mf2['properties'][$k]) and is_array($mf2['properties'][$k])) {
  759. // $mf2['properties'][$v] will always be an array since the input was from the mf2 parser
  760. $value = $mf2['properties'][$k][0];
  761. if(is_string($value)) {
  762. return $value;
  763. } elseif(self::isMicroformat($value) && array_key_exists('value', $value)) {
  764. return $value['value'];
  765. }
  766. }
  767. return $fallback;
  768. }
  769. private static function getHTMLValue($mf2, $k, $fallback=null) {
  770. // Return an array with html and value if the value is html, otherwise return a string
  771. if(!empty($mf2['properties'][$k]) and is_array($mf2['properties'][$k])) {
  772. // $mf2['properties'][$v] will always be an array since the input was from the mf2 parser
  773. $value = $mf2['properties'][$k][0];
  774. if(is_string($value)) {
  775. return $value;
  776. } elseif(isset($value['html'])) {
  777. return $value;
  778. }
  779. }
  780. return $fallback;
  781. }
  782. private static function getPlaintextValues($mf2, $k, $values=[]) {
  783. if(!empty($mf2['properties'][$k]) and is_array($mf2['properties'][$k])) {
  784. foreach($mf2['properties'][$k] as $value) {
  785. if(is_string($value)) {
  786. $values[] = $value;
  787. } elseif(self::isMicroformat($value) && array_key_exists('value', $value)) {
  788. $values[] = $value['value'];
  789. }
  790. }
  791. }
  792. return $values;
  793. }
  794. private static function getURL($url, $http) {
  795. if(!$url || !$http) return null;
  796. // TODO: consider adding caching here
  797. $result = $http->get($url);
  798. if($result['error'] || !$result['body']) {
  799. return null;
  800. }
  801. return \mf2\Parse($result['body'], $url);
  802. }
  803. }