Retrieving information from a feed (we'll cover entries and items in the
next section though they follow identical principals) uses a clearly
defined API which is exactly the same regardless of whether the feed
in question is RSS, RDF or Atom. The same goes for
sub-versions of these standards and we've tested every single
RSS and Atom version. While
the underlying feed XML can differ substantially in terms of the
tags and elements they present, they nonetheless are all trying to
convey similar information and to reflect this all the differences
and wrangling over alternative tags are handled internally by
Zend_Feed_Reader presenting you with an
identical interface for each. Ideally, you should not have to care
whether a feed is RSS or Atom so long as you can extract the
information you want.
Note
While determining common ground between feed types is itself complex, it should be noted that RSS in particular is a constantly disputed "specification". This has its roots in the original RSS 2.0 document which contains ambiguities and does not detail the correct treatment of all elements. As a result, this component rigorously applies the RSS 2.0.11 Specification published by the RSS Advisory Board and its accompanying RSS Best Practices Profile. No other interpretation of RSS 2.0 will be supported though exceptions may be allowed where it does not directly prevent the application of the two documents mentioned above.
Of course, we don't live in an ideal world so there may be times the
API just does not cover what you're looking for. To assist you,
Zend_Feed_Reader offers a plugin system which
allows you to write Extensions to expand the core API and cover any
additional data you are trying to extract from feeds. If writing
another Extension is too much trouble, you can simply grab the
underlying DOM or XPath objects and do it by hand in your
application. Of course, we really do encourage writing an Extension
simply to make it more portable and reusable, and useful Extensions may be proposed
to the Framework for formal addition.
Here's a summary of the Core API for Feeds. You should note it
comprises not only the basic RSS and Atom standards, but also
accounts for a number of included Extensions bundled with
Zend_Feed_Reader. The naming of these
Extension sourced methods remain fairly generic - all Extension
methods operate at the same level as the Core API though we do allow
you to retrieve any specific Extension object separately if required.
Table 66. Feed Level API Methods
getId() |
Returns a unique ID associated with this feed |
getTitle() |
Returns the title of the feed |
getDescription() |
Returns the text description of the feed. |
getLink() |
Returns a URI to the HTML website containing the same or similar information as this feed (i.e. if the feed is from a blog, it should provide the blog's URI where the HTML version of the entries can be read). |
getFeedLink() |
Returns the URI of this feed, which may be the same as the URI used to import the feed. There are important cases where the feed link may differ because the source URI is being updated and is intended to be removed in the future. |
getAuthors() |
Returns an object of type
Zend_Feed_Reader_Collection_Author which is an
ArrayObject whose elements are each simple arrays
containing any combination of the keys "name", "email" and "uri". Where
irrelevant to the source data, some of these keys may be omitted.
|
getAuthor(integer $index = 0) |
Returns either the first author known, or with the
optional $index parameter any specific
index on the array of Authors as described above (returning
NULL if an invalid index).
|
getDateCreated() |
Returns the date on which this feed was created. Generally
only applicable to Atom where it represents the date the resource
described by an Atom 1.0 document was created. The returned date
will be a Zend_Date object.
|
getDateModified() |
Returns the date on which this feed was last modified. The returned date
will be a Zend_Date object.
|
getLastBuildDate() |
Returns the date on which this feed was last built. The returned date
will be a Zend_Date object. This is only
supported by RSS - Atom feeds will always return
NULL.
|
getLanguage() |
Returns the language of the feed (if defined) or simply the language noted in the XML document. |
getGenerator() |
Returns the generator of the feed, e.g. the software which generated it. This may differ between RSS and Atom since Atom defines a different notation. |
getCopyright() |
Returns any copyright notice associated with the feed. |
getHubs() |
Returns an array of all Hub Server URI endpoints which are advertised by the feed for use with the Pubsubhubbub Protocol, allowing subscriptions to the feed for real-time updates. |
getCategories() |
Returns a Zend_Feed_Reader_Collection_Category
object containing the details of any categories associated with the
overall feed. The supported fields include "term" (the machine readable
category name), "scheme" (the categorisation scheme and domain for this
category), and "label" (a HTML decoded human readable
category name). Where any of the three fields are absent from the field,
they are either set to the closest available alternative or, in the case
of "scheme", set to NULL.
|
getImage() |
Returns an array containing data relating to any feed image or logo,
or NULL if no image found. The resulting array may
contain the following keys: uri,
link, title,
description, height, and
width. Atom logos only contain a
URI so the remaining metadata is drawn from
RSS feeds only.
|
Given the variety of feeds in the wild, some of these methods will
undoubtedly return NULL indicating the relevant information
couldn't be located. Where possible, Zend_Feed_Reader
will fall back on alternative elements during its search. For
example, searching an RSS feed for a modification date is more
complicated than it looks. RSS 2.0 feeds should include a
<lastBuildDate> tag and (or) a
<pubDate> element. But what if it doesn't, maybe
this is an RSS 1.0 feed? Perhaps it instead has an
<atom:updated> element with identical information
(Atom may be used to supplement RSS's syntax)? Failing that, we
could simply look at the entries, pick the most recent, and use its
<pubDate> element. Assuming it exists... Many
feeds also use Dublin Core 1.0 or 1.1 <dc:date>
elements for feeds and entries. Or we could find Atom lurking again.
The point is, Zend_Feed_Reader was designed
to know this. When you ask for the modification date (or anything
else), it will run off and search for all these alternatives until
it either gives up and returns NULL, or finds an
alternative that should have the right answer.
In addition to the above methods, all Feed objects implement methods for retrieving the DOM and XPath objects for the current feeds as described earlier. Feed objects also implement the SPL Iterator and Countable interfaces. The extended API is summarised below.
Table 67. Extended Feed Level API Methods
getDomDocument() |
Returns the parent DOMDocument object for the entire source XML document |
getElement() |
Returns the current feed level DOMElement object |
saveXml() |
Returns a string containing an XML document of the entire feed element (this is not the original document but a rebuilt version) |
getXpath() |
Returns the DOMXPath object used internally to run queries on the DOMDocument object (this includes core and Extension namespaces pre-registered) |
getXpathPrefix() |
Returns the valid DOM path prefix prepended to all XPath queries matching the feed being queried |
getEncoding() |
Returns the encoding of the source XML document (note: this cannot account for errors such as the server sending documents in a different encoding). Where not defined, the default UTF-8 encoding of Unicode is applied. |
count() |
Returns a count of the entries or items this feed contains
(implements SPL Countable
interface)
|
current() |
Returns either the current entry (using the current index
from key())
|
key() |
Returns the current entry index |
next() |
Increments the entry index value by one |
rewind() |
Resets the entry index to 0 |
valid() |
Checks that the current entry index is valid, i.e. it does fall below 0 and does not exceed the number of entries existing. |
getExtensions() |
Returns an array of all Extension objects loaded for the current feed (note: both feed-level and entry-level Extensions exist, and only feed-level Extensions are returned here). The array keys are of the form {ExtensionName}_Feed. |
getExtension(string $name) |
Returns an Extension object for the feed registered under the provided name. This allows more fine-grained access to Extensions which may otherwise be hidden within the implementation of the standard API methods. |
getType() |
Returns a static class constant (e.g.
Zend_Feed_Reader::TYPE_ATOM_03,
i.e. Atom 0.3) indicating exactly what kind of feed
is being consumed.
|




