X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs-website;a=blobdiff_plain;f=vendor%2Fzendframework%2Fzend-feed%2Fsrc%2FWriter%2FAbstractFeed.php;fp=vendor%2Fzendframework%2Fzend-feed%2Fsrc%2FWriter%2FAbstractFeed.php;h=a33411397ba2a4b64f41a1a69b540665d7cdaad1;hp=0000000000000000000000000000000000000000;hb=a2bd1bf0c2c1f1a17d188f4dc0726a45494cefae;hpb=57c063afa3f66b07c4bbddc2d6129a96d90f0aad diff --git a/vendor/zendframework/zend-feed/src/Writer/AbstractFeed.php b/vendor/zendframework/zend-feed/src/Writer/AbstractFeed.php new file mode 100644 index 000000000..a33411397 --- /dev/null +++ b/vendor/zendframework/zend-feed/src/Writer/AbstractFeed.php @@ -0,0 +1,877 @@ +_loadExtensions(); + } + + /** + * Set a single author + * + * The following option keys are supported: + * 'name' => (string) The name + * 'email' => (string) An optional email + * 'uri' => (string) An optional and valid URI + * + * @param array $author + * @throws Exception\InvalidArgumentException If any value of $author not follow the format. + * @return AbstractFeed + */ + public function addAuthor(array $author) + { + // Check array values + if (! array_key_exists('name', $author) + || empty($author['name']) + || ! is_string($author['name']) + ) { + throw new Exception\InvalidArgumentException( + 'Invalid parameter: author array must include a "name" key with a non-empty string value' + ); + } + + if (isset($author['email'])) { + if (empty($author['email']) || ! is_string($author['email'])) { + throw new Exception\InvalidArgumentException( + 'Invalid parameter: "email" array value must be a non-empty string' + ); + } + } + if (isset($author['uri'])) { + if (empty($author['uri']) || ! is_string($author['uri']) || + ! Uri::factory($author['uri'])->isValid() + ) { + throw new Exception\InvalidArgumentException( + 'Invalid parameter: "uri" array value must be a non-empty string and valid URI/IRI' + ); + } + } + + $this->data['authors'][] = $author; + + return $this; + } + + /** + * Set an array with feed authors + * + * @see addAuthor + * @param array $authors + * @return AbstractFeed + */ + public function addAuthors(array $authors) + { + foreach ($authors as $author) { + $this->addAuthor($author); + } + + return $this; + } + + /** + * Set the copyright entry + * + * @param string $copyright + * @throws Exception\InvalidArgumentException + * @return AbstractFeed + */ + public function setCopyright($copyright) + { + if (empty($copyright) || ! is_string($copyright)) { + throw new Exception\InvalidArgumentException('Invalid parameter: parameter must be a non-empty string'); + } + $this->data['copyright'] = $copyright; + + return $this; + } + + /** + * Set the feed creation date + * + * @param null|int|DateTime + * @throws Exception\InvalidArgumentException + * @return AbstractFeed + */ + public function setDateCreated($date = null) + { + if ($date === null) { + $date = new DateTime(); + } elseif (is_int($date)) { + $date = new DateTime('@' . $date); + } elseif (! $date instanceof DateTime) { + throw new Exception\InvalidArgumentException('Invalid DateTime object or UNIX Timestamp' + . ' passed as parameter'); + } + $this->data['dateCreated'] = $date; + + return $this; + } + + /** + * Set the feed modification date + * + * @param null|int|DateTime + * @throws Exception\InvalidArgumentException + * @return AbstractFeed + */ + public function setDateModified($date = null) + { + if ($date === null) { + $date = new DateTime(); + } elseif (is_int($date)) { + $date = new DateTime('@' . $date); + } elseif (! $date instanceof DateTime) { + throw new Exception\InvalidArgumentException('Invalid DateTime object or UNIX Timestamp' + . ' passed as parameter'); + } + $this->data['dateModified'] = $date; + + return $this; + } + + /** + * Set the feed last-build date. Ignored for Atom 1.0. + * + * @param null|int|DateTime + * @throws Exception\InvalidArgumentException + * @return AbstractFeed + */ + public function setLastBuildDate($date = null) + { + if ($date === null) { + $date = new DateTime(); + } elseif (is_int($date)) { + $date = new DateTime('@' . $date); + } elseif (! $date instanceof DateTime) { + throw new Exception\InvalidArgumentException('Invalid DateTime object or UNIX Timestamp' + . ' passed as parameter'); + } + $this->data['lastBuildDate'] = $date; + + return $this; + } + + /** + * Set the feed description + * + * @param string $description + * @throws Exception\InvalidArgumentException + * @return AbstractFeed + */ + public function setDescription($description) + { + if (empty($description) || ! is_string($description)) { + throw new Exception\InvalidArgumentException('Invalid parameter: parameter must be a non-empty string'); + } + $this->data['description'] = $description; + + return $this; + } + + /** + * Set the feed generator entry + * + * @param array|string $name + * @param null|string $version + * @param null|string $uri + * @throws Exception\InvalidArgumentException + * @return AbstractFeed + */ + public function setGenerator($name, $version = null, $uri = null) + { + if (is_array($name)) { + $data = $name; + if (empty($data['name']) || ! is_string($data['name'])) { + throw new Exception\InvalidArgumentException('Invalid parameter: "name" must be a non-empty string'); + } + $generator = ['name' => $data['name']]; + if (isset($data['version'])) { + if (empty($data['version']) || ! is_string($data['version'])) { + throw new Exception\InvalidArgumentException( + 'Invalid parameter: "version" must be a non-empty string' + ); + } + $generator['version'] = $data['version']; + } + if (isset($data['uri'])) { + if (empty($data['uri']) || ! is_string($data['uri']) || ! Uri::factory($data['uri'])->isValid()) { + throw new Exception\InvalidArgumentException( + 'Invalid parameter: "uri" must be a non-empty string and a valid URI/IRI' + ); + } + $generator['uri'] = $data['uri']; + } + } else { + if (empty($name) || ! is_string($name)) { + throw new Exception\InvalidArgumentException('Invalid parameter: "name" must be a non-empty string'); + } + $generator = ['name' => $name]; + if (isset($version)) { + if (empty($version) || ! is_string($version)) { + throw new Exception\InvalidArgumentException( + 'Invalid parameter: "version" must be a non-empty string' + ); + } + $generator['version'] = $version; + } + if (isset($uri)) { + if (empty($uri) || ! is_string($uri) || ! Uri::factory($uri)->isValid()) { + throw new Exception\InvalidArgumentException( + 'Invalid parameter: "uri" must be a non-empty string and a valid URI/IRI' + ); + } + $generator['uri'] = $uri; + } + } + $this->data['generator'] = $generator; + + return $this; + } + + /** + * Set the feed ID - URI or URN (via PCRE pattern) supported + * + * @param string $id + * @throws Exception\InvalidArgumentException + * @return AbstractFeed + */ + public function setId($id) + { + // @codingStandardsIgnoreStart + if ((empty($id) || ! is_string($id) || ! Uri::factory($id)->isValid()) + && ! preg_match("#^urn:[a-zA-Z0-9][a-zA-Z0-9\-]{1,31}:([a-zA-Z0-9\(\)\+\,\.\:\=\@\;\$\_\!\*\-]|%[0-9a-fA-F]{2})*#", $id) + && ! $this->_validateTagUri($id) + ) { + // @codingStandardsIgnoreEnd + throw new Exception\InvalidArgumentException( + 'Invalid parameter: parameter must be a non-empty string and valid URI/IRI' + ); + } + $this->data['id'] = $id; + + return $this; + } + + /** + * Validate a URI using the tag scheme (RFC 4151) + * + * @param string $id + * @return bool + */ + // @codingStandardsIgnoreStart + protected function _validateTagUri($id) + { + // @codingStandardsIgnoreEnd + if (preg_match( + '/^tag:(?P.*),(?P\d{4}-?\d{0,2}-?\d{0,2}):(?P.*)(.*:)*$/', + $id, + $matches + )) { + $dvalid = false; + $date = $matches['date']; + $d6 = strtotime($date); + if ((strlen($date) == 4) && $date <= date('Y')) { + $dvalid = true; + } elseif ((strlen($date) == 7) && ($d6 < strtotime("now"))) { + $dvalid = true; + } elseif ((strlen($date) == 10) && ($d6 < strtotime("now"))) { + $dvalid = true; + } + $validator = new Validator\EmailAddress; + if ($validator->isValid($matches['name'])) { + $nvalid = true; + } else { + $nvalid = $validator->isValid('info@' . $matches['name']); + } + return $dvalid && $nvalid; + } + return false; + } + + /** + * Set a feed image (URI at minimum). Parameter is a single array with the + * required key 'uri'. When rendering as RSS, the required keys are 'uri', + * 'title' and 'link'. RSS also specifies three optional parameters 'width', + * 'height' and 'description'. Only 'uri' is required and used for Atom rendering. + * + * @param array $data + * @throws Exception\InvalidArgumentException + * @return AbstractFeed + */ + public function setImage(array $data) + { + if (empty($data['uri']) || ! is_string($data['uri']) + || ! Uri::factory($data['uri'])->isValid() + ) { + throw new Exception\InvalidArgumentException('Invalid parameter: parameter \'uri\'' + . ' must be a non-empty string and valid URI/IRI'); + } + $this->data['image'] = $data; + + return $this; + } + + /** + * Set the feed language + * + * @param string $language + * @throws Exception\InvalidArgumentException + * @return AbstractFeed + */ + public function setLanguage($language) + { + if (empty($language) || ! is_string($language)) { + throw new Exception\InvalidArgumentException('Invalid parameter: parameter must be a non-empty string'); + } + $this->data['language'] = $language; + + return $this; + } + + /** + * Set a link to the HTML source + * + * @param string $link + * @throws Exception\InvalidArgumentException + * @return AbstractFeed + */ + public function setLink($link) + { + if (empty($link) || ! is_string($link) || ! Uri::factory($link)->isValid()) { + throw new Exception\InvalidArgumentException( + 'Invalid parameter: parameter must be a non-empty string and valid URI/IRI' + ); + } + $this->data['link'] = $link; + + return $this; + } + + /** + * Set a link to an XML feed for any feed type/version + * + * @param string $link + * @param string $type + * @throws Exception\InvalidArgumentException + * @return AbstractFeed + */ + public function setFeedLink($link, $type) + { + if (empty($link) || ! is_string($link) || ! Uri::factory($link)->isValid()) { + throw new Exception\InvalidArgumentException( + 'Invalid parameter: "link"" must be a non-empty string and valid URI/IRI' + ); + } + if (! in_array(strtolower($type), ['rss', 'rdf', 'atom'])) { + throw new Exception\InvalidArgumentException( + 'Invalid parameter: "type"; You must declare the type of feed the link points to, i.e. RSS, RDF or Atom' + ); + } + $this->data['feedLinks'][strtolower($type)] = $link; + + return $this; + } + + /** + * Set the feed title + * + * @param string $title + * @throws Exception\InvalidArgumentException + * @return AbstractFeed + */ + public function setTitle($title) + { + if (empty($title) || ! is_string($title)) { + throw new Exception\InvalidArgumentException('Invalid parameter: parameter must be a non-empty string'); + } + $this->data['title'] = $title; + + return $this; + } + + /** + * Set the feed character encoding + * + * @param string $encoding + * @throws Exception\InvalidArgumentException + * @return AbstractFeed + */ + public function setEncoding($encoding) + { + if (empty($encoding) || ! is_string($encoding)) { + throw new Exception\InvalidArgumentException('Invalid parameter: parameter must be a non-empty string'); + } + $this->data['encoding'] = $encoding; + + return $this; + } + + /** + * Set the feed's base URL + * + * @param string $url + * @throws Exception\InvalidArgumentException + * @return AbstractFeed + */ + public function setBaseUrl($url) + { + if (empty($url) || ! is_string($url) || ! Uri::factory($url)->isValid()) { + throw new Exception\InvalidArgumentException('Invalid parameter: "url" array value' + . ' must be a non-empty string and valid URI/IRI'); + } + $this->data['baseUrl'] = $url; + + return $this; + } + + /** + * Add a Pubsubhubbub hub endpoint URL + * + * @param string $url + * @throws Exception\InvalidArgumentException + * @return AbstractFeed + */ + public function addHub($url) + { + if (empty($url) || ! is_string($url) || ! Uri::factory($url)->isValid()) { + throw new Exception\InvalidArgumentException('Invalid parameter: "url" array value' + . ' must be a non-empty string and valid URI/IRI'); + } + if (! isset($this->data['hubs'])) { + $this->data['hubs'] = []; + } + $this->data['hubs'][] = $url; + + return $this; + } + + /** + * Add Pubsubhubbub hub endpoint URLs + * + * @param array $urls + * @return AbstractFeed + */ + public function addHubs(array $urls) + { + foreach ($urls as $url) { + $this->addHub($url); + } + + return $this; + } + + /** + * Add a feed category + * + * @param array $category + * @throws Exception\InvalidArgumentException + * @return AbstractFeed + */ + public function addCategory(array $category) + { + if (! isset($category['term'])) { + throw new Exception\InvalidArgumentException('Each category must be an array and ' + . 'contain at least a "term" element containing the machine ' + . ' readable category name'); + } + if (isset($category['scheme'])) { + if (empty($category['scheme']) + || ! is_string($category['scheme']) + || ! Uri::factory($category['scheme'])->isValid() + ) { + throw new Exception\InvalidArgumentException('The Atom scheme or RSS domain of' + . ' a category must be a valid URI'); + } + } + if (! isset($this->data['categories'])) { + $this->data['categories'] = []; + } + $this->data['categories'][] = $category; + + return $this; + } + + /** + * Set an array of feed categories + * + * @param array $categories + * @return AbstractFeed + */ + public function addCategories(array $categories) + { + foreach ($categories as $category) { + $this->addCategory($category); + } + + return $this; + } + + /** + * Get a single author + * + * @param int $index + * @return string|null + */ + public function getAuthor($index = 0) + { + if (isset($this->data['authors'][$index])) { + return $this->data['authors'][$index]; + } + + return; + } + + /** + * Get an array with feed authors + * + * @return array + */ + public function getAuthors() + { + if (! array_key_exists('authors', $this->data)) { + return; + } + return $this->data['authors']; + } + + /** + * Get the copyright entry + * + * @return string|null + */ + public function getCopyright() + { + if (! array_key_exists('copyright', $this->data)) { + return; + } + return $this->data['copyright']; + } + + /** + * Get the feed creation date + * + * @return string|null + */ + public function getDateCreated() + { + if (! array_key_exists('dateCreated', $this->data)) { + return; + } + return $this->data['dateCreated']; + } + + /** + * Get the feed modification date + * + * @return string|null + */ + public function getDateModified() + { + if (! array_key_exists('dateModified', $this->data)) { + return; + } + return $this->data['dateModified']; + } + + /** + * Get the feed last-build date + * + * @return string|null + */ + public function getLastBuildDate() + { + if (! array_key_exists('lastBuildDate', $this->data)) { + return; + } + return $this->data['lastBuildDate']; + } + + /** + * Get the feed description + * + * @return string|null + */ + public function getDescription() + { + if (! array_key_exists('description', $this->data)) { + return; + } + return $this->data['description']; + } + + /** + * Get the feed generator entry + * + * @return string|null + */ + public function getGenerator() + { + if (! array_key_exists('generator', $this->data)) { + return; + } + return $this->data['generator']; + } + + /** + * Get the feed ID + * + * @return string|null + */ + public function getId() + { + if (! array_key_exists('id', $this->data)) { + return; + } + return $this->data['id']; + } + + /** + * Get the feed image URI + * + * @return array + */ + public function getImage() + { + if (! array_key_exists('image', $this->data)) { + return; + } + return $this->data['image']; + } + + /** + * Get the feed language + * + * @return string|null + */ + public function getLanguage() + { + if (! array_key_exists('language', $this->data)) { + return; + } + return $this->data['language']; + } + + /** + * Get a link to the HTML source + * + * @return string|null + */ + public function getLink() + { + if (! array_key_exists('link', $this->data)) { + return; + } + return $this->data['link']; + } + + /** + * Get a link to the XML feed + * + * @return string|null + */ + public function getFeedLinks() + { + if (! array_key_exists('feedLinks', $this->data)) { + return; + } + return $this->data['feedLinks']; + } + + /** + * Get the feed title + * + * @return string|null + */ + public function getTitle() + { + if (! array_key_exists('title', $this->data)) { + return; + } + return $this->data['title']; + } + + /** + * Get the feed character encoding + * + * @return string|null + */ + public function getEncoding() + { + if (! array_key_exists('encoding', $this->data)) { + return 'UTF-8'; + } + return $this->data['encoding']; + } + + /** + * Get the feed's base url + * + * @return string|null + */ + public function getBaseUrl() + { + if (! array_key_exists('baseUrl', $this->data)) { + return; + } + return $this->data['baseUrl']; + } + + /** + * Get the URLs used as Pubsubhubbub hubs endpoints + * + * @return string|null + */ + public function getHubs() + { + if (! array_key_exists('hubs', $this->data)) { + return; + } + return $this->data['hubs']; + } + + /** + * Get the feed categories + * + * @return string|null + */ + public function getCategories() + { + if (! array_key_exists('categories', $this->data)) { + return; + } + return $this->data['categories']; + } + + /** + * Resets the instance and deletes all data + * + * @return void + */ + public function reset() + { + $this->data = []; + } + + /** + * Set the current feed type being exported to "rss" or "atom". This allows + * other objects to gracefully choose whether to execute or not, depending + * on their appropriateness for the current type, e.g. renderers. + * + * @param string $type + * @return AbstractFeed + */ + public function setType($type) + { + $this->type = $type; + return $this; + } + + /** + * Retrieve the current or last feed type exported. + * + * @return string Value will be "rss" or "atom" + */ + public function getType() + { + return $this->type; + } + + /** + * Unset a specific data point + * + * @param string $name + * @return AbstractFeed + */ + public function remove($name) + { + if (isset($this->data[$name])) { + unset($this->data[$name]); + } + return $this; + } + + /** + * Method overloading: call given method on first extension implementing it + * + * @param string $method + * @param array $args + * @return mixed + * @throws Exception\BadMethodCallException if no extensions implements the method + */ + public function __call($method, $args) + { + foreach ($this->extensions as $extension) { + try { + return call_user_func_array([$extension, $method], $args); + } catch (Exception\BadMethodCallException $e) { + } + } + throw new Exception\BadMethodCallException( + 'Method: ' . $method . ' does not exist and could not be located on a registered Extension' + ); + } + + /** + * Load extensions from Zend\Feed\Writer\Writer + * + * @throws Exception\RuntimeException + * @return void + */ + // @codingStandardsIgnoreStart + protected function _loadExtensions() + { + // @codingStandardsIgnoreEnd + $all = Writer::getExtensions(); + $manager = Writer::getExtensionManager(); + $exts = $all['feed']; + foreach ($exts as $ext) { + if (! $manager->has($ext)) { + throw new Exception\RuntimeException( + sprintf('Unable to load extension "%s"; could not resolve to class', $ext) + ); + } + $this->extensions[$ext] = $manager->get($ext); + $this->extensions[$ext]->setEncoding($this->getEncoding()); + } + } +}