You are here

class AbstractFeed in Zircon Profile 8.0

Same name in this branch
  1. 8.0 vendor/zendframework/zend-feed/src/Reader/AbstractFeed.php \Zend\Feed\Reader\AbstractFeed
  2. 8.0 vendor/zendframework/zend-feed/src/Writer/AbstractFeed.php \Zend\Feed\Writer\AbstractFeed
  3. 8.0 vendor/zendframework/zend-feed/src/Reader/Extension/AbstractFeed.php \Zend\Feed\Reader\Extension\AbstractFeed
  4. 8.0 vendor/zendframework/zend-feed/src/Reader/Feed/AbstractFeed.php \Zend\Feed\Reader\Feed\AbstractFeed
Same name and namespace in other branches
  1. 8 vendor/zendframework/zend-feed/src/Writer/AbstractFeed.php \Zend\Feed\Writer\AbstractFeed

Hierarchy

Expanded class hierarchy of AbstractFeed

File

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

Namespace

Zend\Feed\Writer
View source
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

Namesort descending 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.