www.aleph1.co.uk Git - yaffs-website/blob - vendor/zendframework/zend-feed/src/Writer/Writer.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Feed\Writer;
  11
  12 /**
  13 */
  14 class Writer
  15 {
  16     /**
  17      * Namespace constants
  18      */
  19     const NAMESPACE_ATOM_03  = 'http://purl.org/atom/ns#';
  20     const NAMESPACE_ATOM_10  = 'http://www.w3.org/2005/Atom';
  21     const NAMESPACE_RDF      = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';
  22     const NAMESPACE_RSS_090  = 'http://my.netscape.com/rdf/simple/0.9/';
  23     const NAMESPACE_RSS_10   = 'http://purl.org/rss/1.0/';
  24
  25     /**
  26      * Feed type constants
  27      */
  28     const TYPE_ANY              = 'any';
  29     const TYPE_ATOM_03          = 'atom-03';
  30     const TYPE_ATOM_10          = 'atom-10';
  31     const TYPE_ATOM_ANY         = 'atom';
  32     const TYPE_RSS_090          = 'rss-090';
  33     const TYPE_RSS_091          = 'rss-091';
  34     const TYPE_RSS_091_NETSCAPE = 'rss-091n';
  35     const TYPE_RSS_091_USERLAND = 'rss-091u';
  36     const TYPE_RSS_092          = 'rss-092';
  37     const TYPE_RSS_093          = 'rss-093';
  38     const TYPE_RSS_094          = 'rss-094';
  39     const TYPE_RSS_10           = 'rss-10';
  40     const TYPE_RSS_20           = 'rss-20';
  41     const TYPE_RSS_ANY          = 'rss';
  42
  43     /**
  44      * @var ExtensionManagerInterface
  45      */
  46     protected static $extensionManager = null;
  47
  48     /**
  49      * Array of registered extensions by class postfix (after the base class
  50      * name) across four categories - data containers and renderers for entry
  51      * and feed levels.
  52      *
  53      * @var array
  54      */
  55     protected static $extensions = [
  56         'entry'         => [],
  57         'feed'          => [],
  58         'entryRenderer' => [],
  59         'feedRenderer'  => [],
  60     ];
  61
  62     /**
  63      * Set plugin loader for use with Extensions
  64      *
  65      * @param ExtensionManagerInterface
  66      */
  67     public static function setExtensionManager(ExtensionManagerInterface $extensionManager)
  68     {
  69         static::$extensionManager = $extensionManager;
  70     }
  71
  72     /**
  73      * Get plugin manager for use with Extensions
  74      *
  75      * @return ExtensionManagerInterface
  76      */
  77     public static function getExtensionManager()
  78     {
  79         if (! isset(static::$extensionManager)) {
  80             static::setExtensionManager(new ExtensionManager());
  81         }
  82         return static::$extensionManager;
  83     }
  84
  85     /**
  86      * Register an Extension by name
  87      *
  88      * @param  string $name
  89      * @return void
  90      * @throws Exception\RuntimeException if unable to resolve Extension class
  91      */
  92     public static function registerExtension($name)
  93     {
  94         if (! static::hasExtension($name)) {
  95             throw new Exception\RuntimeException(sprintf(
  96                 'Could not load extension "%s" using Plugin Loader.'
  97                 . ' Check prefix paths are configured and extension exists.',
  98                 $name
  99             ));
 100         }
 101
 102         if (static::isRegistered($name)) {
 103             return;
 104         }
 105
 106         $manager = static::getExtensionManager();
 107
 108         $feedName = $name . '\Feed';
 109         if ($manager->has($feedName)) {
 110             static::$extensions['feed'][] = $feedName;
 111         }
 112
 113         $entryName = $name . '\Entry';
 114         if ($manager->has($entryName)) {
 115             static::$extensions['entry'][] = $entryName;
 116         }
 117
 118         $feedRendererName = $name . '\Renderer\Feed';
 119         if ($manager->has($feedRendererName)) {
 120             static::$extensions['feedRenderer'][] = $feedRendererName;
 121         }
 122
 123         $entryRendererName = $name . '\Renderer\Entry';
 124         if ($manager->has($entryRendererName)) {
 125             static::$extensions['entryRenderer'][] = $entryRendererName;
 126         }
 127     }
 128
 129     /**
 130      * Is a given named Extension registered?
 131      *
 132      * @param  string $extensionName
 133      * @return bool
 134      */
 135     public static function isRegistered($extensionName)
 136     {
 137         $feedName          = $extensionName . '\Feed';
 138         $entryName         = $extensionName . '\Entry';
 139         $feedRendererName  = $extensionName . '\Renderer\Feed';
 140         $entryRendererName = $extensionName . '\Renderer\Entry';
 141         if (in_array($feedName, static::$extensions['feed'])
 142             || in_array($entryName, static::$extensions['entry'])
 143             || in_array($feedRendererName, static::$extensions['feedRenderer'])
 144             || in_array($entryRendererName, static::$extensions['entryRenderer'])
 145         ) {
 146             return true;
 147         }
 148         return false;
 149     }
 150
 151     /**
 152      * Get a list of extensions
 153      *
 154      * @return array
 155      */
 156     public static function getExtensions()
 157     {
 158         return static::$extensions;
 159     }
 160
 161     /**
 162      * Reset class state to defaults
 163      *
 164      * @return void
 165      */
 166     public static function reset()
 167     {
 168         static::$extensionManager = null;
 169         static::$extensions   = [
 170             'entry'         => [],
 171             'feed'          => [],
 172             'entryRenderer' => [],
 173             'feedRenderer'  => [],
 174         ];
 175     }
 176
 177     /**
 178      * Register core (default) extensions
 179      *
 180      * @return void
 181      */
 182     public static function registerCoreExtensions()
 183     {
 184         static::registerExtension('DublinCore');
 185         static::registerExtension('Content');
 186         static::registerExtension('Atom');
 187         static::registerExtension('Slash');
 188         static::registerExtension('WellFormedWeb');
 189         static::registerExtension('Threading');
 190         static::registerExtension('ITunes');
 191
 192         // Added in 2.10.0; check for it conditionally
 193         static::hasExtension('GooglePlayPodcast')
 194             ? static::registerExtension('GooglePlayPodcast')
 195             : trigger_error(
 196                 sprintf(
 197                     'Please update your %1$s\ExtensionManagerInterface implementation to add entries for'
 198                     . ' %1$s\Extension\GooglePlayPodcast\Entry,'
 199                     . ' %1$s\Extension\GooglePlayPodcast\Feed,'
 200                     . ' %1$s\Extension\GooglePlayPodcast\Renderer\Entry,'
 201                     . ' and %1$s\Extension\GooglePlayPodcast\Renderer\Feed.',
 202                     __NAMESPACE__
 203                 ),
 204                 \E_USER_NOTICE
 205             );
 206     }
 207
 208     public static function lcfirst($str)
 209     {
 210         $str[0] = strtolower($str[0]);
 211         return $str;
 212     }
 213
 214     /**
 215      * Does the extension manager have the named extension?
 216      *
 217      * This method exists to allow us to test if an extension is present in the
 218      * extension manager. It may be used by registerExtension() to determine if
 219      * the extension has items present in the manager, or by
 220      * registerCoreExtension() to determine if the core extension has entries
 221      * in the extension manager. In the latter case, this can be useful when
 222      * adding new extensions in a minor release, as custom extension manager
 223      * implementations may not yet have an entry for the extension, which would
 224      * then otherwise cause registerExtension() to fail.
 225      *
 226      * @param string $name
 227      * @return bool
 228      */
 229     protected static function hasExtension($name)
 230     {
 231         $manager   = static::getExtensionManager();
 232
 233         $feedName          = $name . '\Feed';
 234         $entryName         = $name . '\Entry';
 235         $feedRendererName  = $name . '\Renderer\Feed';
 236         $entryRendererName = $name . '\Renderer\Entry';
 237
 238         return $manager->has($feedName)
 239             || $manager->has($entryName)
 240             || $manager->has($feedRendererName)
 241             || $manager->has($entryRendererName);
 242     }
 243 }