class AbstractFeed in Zircon Profile 8.0

Hierarchy

• class \Zend\Feed\Writer\AbstractFeed

File

vendor/zendframework/zend-feed/src/Writer/AbstractFeed.php, line 16

Namespace

Zend\Feed\Writer

class AbstractFeed {

  /**
   * Contains all Feed level date to append in feed output
   *
   * @var array
   */
  protected $data = [];

  /**
   * Holds the value "atom" or "rss" depending on the feed type set when
   * when last exported.
   *
   * @var string
   */
  protected $type = null;

  /**
   * @var $extensions
   */
  protected $extensions;

  /**
   * Constructor: Primarily triggers the registration of core extensions and
   * loads those appropriate to this data container.
   *
   */
  public function __construct() {
    Writer::registerCoreExtensions();
    $this
      ->_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) {
    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)) {
      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
   */
  protected function _validateTagUri($id) {
    if (preg_match('/^tag:(?P<name>.*),(?P<date>\\d{4}-?\\d{0,2}-?\\d{0,2}):(?P<specific>.*)(.*:)*$/', $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
   */
  protected function _loadExtensions() {
    $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());
    }
  }

}

Members

Name	Modifiers	Type	Description	Overrides
AbstractFeed::$data	protected	property	Contains all Feed level date to append in feed output
AbstractFeed::$extensions	protected	property
AbstractFeed::$type	protected	property	Holds the value "atom" or "rss" depending on the feed type set when when last exported.
AbstractFeed::addAuthor	public	function	Set a single author
AbstractFeed::addAuthors	public	function	Set an array with feed authors
AbstractFeed::addCategories	public	function	Set an array of feed categories
AbstractFeed::addCategory	public	function	Add a feed category
AbstractFeed::addHub	public	function	Add a Pubsubhubbub hub endpoint URL
AbstractFeed::addHubs	public	function	Add Pubsubhubbub hub endpoint URLs
AbstractFeed::getAuthor	public	function	Get a single author
AbstractFeed::getAuthors	public	function	Get an array with feed authors
AbstractFeed::getBaseUrl	public	function	Get the feed's base url
AbstractFeed::getCategories	public	function	Get the feed categories
AbstractFeed::getCopyright	public	function	Get the copyright entry
AbstractFeed::getDateCreated	public	function	Get the feed creation date
AbstractFeed::getDateModified	public	function	Get the feed modification date
AbstractFeed::getDescription	public	function	Get the feed description
AbstractFeed::getEncoding	public	function	Get the feed character encoding
AbstractFeed::getFeedLinks	public	function	Get a link to the XML feed
AbstractFeed::getGenerator	public	function	Get the feed generator entry
AbstractFeed::getHubs	public	function	Get the URLs used as Pubsubhubbub hubs endpoints
AbstractFeed::getId	public	function	Get the feed ID
AbstractFeed::getImage	public	function	Get the feed image URI
AbstractFeed::getLanguage	public	function	Get the feed language
AbstractFeed::getLastBuildDate	public	function	Get the feed last-build date
AbstractFeed::getLink	public	function	Get a link to the HTML source
AbstractFeed::getTitle	public	function	Get the feed title
AbstractFeed::getType	public	function	Retrieve the current or last feed type exported.
AbstractFeed::remove	public	function	Unset a specific data point
AbstractFeed::reset	public	function	Resets the instance and deletes all data
AbstractFeed::setBaseUrl	public	function	Set the feed's base URL
AbstractFeed::setCopyright	public	function	Set the copyright entry
AbstractFeed::setDateCreated	public	function	Set the feed creation date
AbstractFeed::setDateModified	public	function	Set the feed modification date
AbstractFeed::setDescription	public	function	Set the feed description
AbstractFeed::setEncoding	public	function	Set the feed character encoding
AbstractFeed::setFeedLink	public	function	Set a link to an XML feed for any feed type/version
AbstractFeed::setGenerator	public	function	Set the feed generator entry
AbstractFeed::setId	public	function	Set the feed ID - URI or URN (via PCRE pattern) supported
AbstractFeed::setImage	public	function	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…
AbstractFeed::setLanguage	public	function	Set the feed language
AbstractFeed::setLastBuildDate	public	function	Set the feed last-build date. Ignored for Atom 1.0.
AbstractFeed::setLink	public	function	Set a link to the HTML source
AbstractFeed::setTitle	public	function	Set the feed title
AbstractFeed::setType	public	function	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.
AbstractFeed::_loadExtensions	protected	function	Load extensions from Zend\Feed\Writer\Writer
AbstractFeed::_validateTagUri	protected	function	Validate a URI using the tag scheme (RFC 4151)
AbstractFeed::__call	public	function	Method overloading: call given method on first extension implementing it
AbstractFeed::__construct	public	function	Constructor: Primarily triggers the registration of core extensions and loads those appropriate to this data container.