| Current File : /home/k/a/r/karenpetzb/www/items/category/Element.php.tar |
home/karenpetzb/library/Zend/Form/Element.php 0000604 00000161501 15071273144 0015216 0 ustar 00 <?php
/**
* Zend Framework
*
* LICENSE
*
* This source file is subject to the new BSD license that is bundled
* with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://framework.zend.com/license/new-bsd
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@zend.com so we can send you a copy immediately.
*
* @category Zend
* @package Zend_Form
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
/** Zend_Filter */
require_once 'Zend/Filter.php';
/** Zend_Validate_Interface */
require_once 'Zend/Validate/Interface.php';
/**
* Zend_Form_Element
*
* @category Zend
* @package Zend_Form
* @subpackage Element
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
* @version $Id: Element.php 12787 2008-11-23 14:17:44Z matthew $
*/
class Zend_Form_Element implements Zend_Validate_Interface
{
/**
* Element Constants
*/
const DECORATOR = 'DECORATOR';
const FILTER = 'FILTER';
const VALIDATE = 'VALIDATE';
/**
* Default view helper to use
* @var string
*/
public $helper = 'formText';
/**
* 'Allow empty' flag
* @var bool
*/
protected $_allowEmpty = true;
/**
* Flag indicating whether or not to insert NotEmpty validator when element is required
* @var bool
*/
protected $_autoInsertNotEmptyValidator = true;
/**
* Array to which element belongs
* @var string
*/
protected $_belongsTo;
/**
* Element decorators
* @var array
*/
protected $_decorators = array();
/**
* Element description
* @var string
*/
protected $_description;
/**
* Should we disable loading the default decorators?
* @var bool
*/
protected $_disableLoadDefaultDecorators = false;
/**
* Custom error messages
* @var array
*/
protected $_errorMessages = array();
/**
* Validation errors
* @var array
*/
protected $_errors = array();
/**
* Element filters
* @var array
*/
protected $_filters = array();
/**
* Ignore flag (used when retrieving values at form level)
* @var bool
*/
protected $_ignore = false;
/**
* Does the element represent an array?
* @var bool
*/
protected $_isArray = false;
/**
* Is the error marked as in an invalid state?
* @var bool
*/
protected $_isError = false;
/**
* Element label
* @var string
*/
protected $_label;
/**
* Plugin loaders for filter and validator chains
* @var array
*/
protected $_loaders = array();
/**
* Formatted validation error messages
* @var array
*/
protected $_messages = array();
/**
* Element name
* @var string
*/
protected $_name;
/**
* Order of element
* @var int
*/
protected $_order;
/**
* Required flag
* @var bool
*/
protected $_required = false;
/**
* @var Zend_Translate
*/
protected $_translator;
/**
* Is translation disabled?
* @var bool
*/
protected $_translatorDisabled = false;
/**
* Element type
* @var string
*/
protected $_type;
/**
* Array of initialized validators
* @var array Validators
*/
protected $_validators = array();
/**
* Array of un-initialized validators
* @var array
*/
protected $_validatorRules = array();
/**
* Element value
* @var mixed
*/
protected $_value;
/**
* @var Zend_View_Interface
*/
protected $_view;
/**
* Constructor
*
* $spec may be:
* - string: name of element
* - array: options with which to configure element
* - Zend_Config: Zend_Config with options for configuring element
*
* @param string|array|Zend_Config $spec
* @return void
* @throws Zend_Form_Exception if no element name after initialization
*/
public function __construct($spec, $options = null)
{
if (is_string($spec)) {
$this->setName($spec);
} elseif (is_array($spec)) {
$this->setOptions($spec);
} elseif ($spec instanceof Zend_Config) {
$this->setConfig($spec);
}
if (is_string($spec) && is_array($options)) {
$this->setOptions($options);
} elseif (is_string($spec) && ($options instanceof Zend_Config)) {
$this->setConfig($options);
}
if (null === $this->getName()) {
require_once 'Zend/Form/Exception.php';
throw new Zend_Form_Exception('Zend_Form_Element requires each element to have a name');
}
/**
* Extensions
*/
$this->init();
/**
* Register ViewHelper decorator by default
*/
$this->loadDefaultDecorators();
}
/**
* Initialize object; used by extending classes
*
* @return void
*/
public function init()
{
}
/**
* Set flag to disable loading default decorators
*
* @param bool $flag
* @return Zend_Form_Element
*/
public function setDisableLoadDefaultDecorators($flag)
{
$this->_disableLoadDefaultDecorators = (bool) $flag;
return $this;
}
/**
* Should we load the default decorators?
*
* @return bool
*/
public function loadDefaultDecoratorsIsDisabled()
{
return $this->_disableLoadDefaultDecorators;
}
/**
* Load default decorators
*
* @return void
*/
public function loadDefaultDecorators()
{
if ($this->loadDefaultDecoratorsIsDisabled()) {
return;
}
$decorators = $this->getDecorators();
if (empty($decorators)) {
$this->addDecorator('ViewHelper')
->addDecorator('Errors')
->addDecorator('Description', array('tag' => 'p', 'class' => 'description'))
->addDecorator('HtmlTag', array('tag' => 'dd'))
->addDecorator('Label', array('tag' => 'dt'));
}
}
/**
* Set object state from options array
*
* @param array $options
* @return Zend_Form_Element
*/
public function setOptions(array $options)
{
if (isset($options['prefixPath'])) {
$this->addPrefixPaths($options['prefixPath']);
unset($options['prefixPath']);
}
if (isset($options['disableTranslator'])) {
$this->setDisableTranslator($options['disableTranslator']);
unset($options['disableTranslator']);
}
unset($options['options']);
unset($options['config']);
foreach ($options as $key => $value) {
$method = 'set' . ucfirst($key);
if (in_array($method, array('setTranslator', 'setPluginLoader', 'setView'))) {
if (!is_object($value)) {
continue;
}
}
if (method_exists($this, $method)) {
// Setter exists; use it
$this->$method($value);
} else {
// Assume it's metadata
$this->setAttrib($key, $value);
}
}
return $this;
}
/**
* Set object state from Zend_Config object
*
* @param Zend_Config $config
* @return Zend_Form_Element
*/
public function setConfig(Zend_Config $config)
{
return $this->setOptions($config->toArray());
}
// Localization:
/**
* Set translator object for localization
*
* @param Zend_Translate|null $translator
* @return Zend_Form_Element
*/
public function setTranslator($translator = null)
{
if (null === $translator) {
$this->_translator = null;
} elseif ($translator instanceof Zend_Translate_Adapter) {
$this->_translator = $translator;
} elseif ($translator instanceof Zend_Translate) {
$this->_translator = $translator->getAdapter();
} else {
require_once 'Zend/Form/Exception.php';
throw new Zend_Form_Exception('Invalid translator specified');
}
return $this;
}
/**
* Retrieve localization translator object
*
* @return Zend_Translate_Adapter|null
*/
public function getTranslator()
{
if ($this->translatorIsDisabled()) {
return null;
}
if (null === $this->_translator) {
require_once 'Zend/Form.php';
return Zend_Form::getDefaultTranslator();
}
return $this->_translator;
}
/**
* Indicate whether or not translation should be disabled
*
* @param bool $flag
* @return Zend_Form_Element
*/
public function setDisableTranslator($flag)
{
$this->_translatorDisabled = (bool) $flag;
return $this;
}
/**
* Is translation disabled?
*
* @return bool
*/
public function translatorIsDisabled()
{
return $this->_translatorDisabled;
}
// Metadata
/**
* Filter a name to only allow valid variable characters
*
* @param string $value
* @param bool $allowBrackets
* @return string
*/
public function filterName($value, $allowBrackets = false)
{
$charset = '^a-zA-Z0-9_\x7f-\xff';
if ($allowBrackets) {
$charset .= '\[\]';
}
return preg_replace('/[' . $charset . ']/', '', (string) $value);
}
/**
* Set element name
*
* @param string $name
* @return Zend_Form_Element
*/
public function setName($name)
{
$name = $this->filterName($name);
if ('' === $name) {
require_once 'Zend/Form/Exception.php';
throw new Zend_Form_Exception('Invalid name provided; must contain only valid variable characters and be non-empty');
}
$this->_name = $name;
return $this;
}
/**
* Return element name
*
* @return string
*/
public function getName()
{
return $this->_name;
}
/**
* Get fully qualified name
*
* Places name as subitem of array and/or appends brackets.
*
* @return string
*/
public function getFullyQualifiedName()
{
$name = $this->getName();
if (null !== ($belongsTo = $this->getBelongsTo())) {
$name = $belongsTo . '[' . $name . ']';
}
if ($this->isArray()) {
$name .= '[]';
}
return $name;
}
/**
* Get element id
*
* @return string
*/
public function getId()
{
if (isset($this->id)) {
return $this->id;
}
$id = $this->getFullyQualifiedName();
// Bail early if no array notation detected
if (!strstr($id, '[')) {
return $id;
}
// Strip array notation
if ('[]' == substr($id, -2)) {
$id = substr($id, 0, strlen($id) - 2);
}
$id = str_replace('][', '-', $id);
$id = str_replace(array(']', '['), '-', $id);
$id = trim($id, '-');
return $id;
}
/**
* Set element value
*
* @param mixed $value
* @return Zend_Form_Element
*/
public function setValue($value)
{
$this->_value = $value;
return $this;
}
/**
* Filter a value
*
* @param string $value
* @param string $key
* @return void
*/
protected function _filterValue(&$value, &$key)
{
foreach ($this->getFilters() as $filter) {
$value = $filter->filter($value);
}
}
/**
* Retrieve filtered element value
*
* @return mixed
*/
public function getValue()
{
$valueFiltered = $this->_value;
if ($this->isArray() && is_array($valueFiltered)) {
array_walk_recursive($valueFiltered, array($this, '_filterValue'));
} else {
$this->_filterValue($valueFiltered, $valueFiltered);
}
return $valueFiltered;
}
/**
* Retrieve unfiltered element value
*
* @return mixed
*/
public function getUnfilteredValue()
{
return $this->_value;
}
/**
* Set element label
*
* @param string $label
* @return Zend_Form_Element
*/
public function setLabel($label)
{
$this->_label = (string) $label;
return $this;
}
/**
* Retrieve element label
*
* @return string
*/
public function getLabel()
{
return $this->_label;
}
/**
* Set element order
*
* @param int $order
* @return Zend_Form_Element
*/
public function setOrder($order)
{
$this->_order = (int) $order;
return $this;
}
/**
* Retrieve element order
*
* @return int
*/
public function getOrder()
{
return $this->_order;
}
/**
* Set required flag
*
* @param bool $flag Default value is true
* @return Zend_Form_Element
*/
public function setRequired($flag = true)
{
$this->_required = (bool) $flag;
return $this;
}
/**
* Is the element required?
*
* @return bool
*/
public function isRequired()
{
return $this->_required;
}
/**
* Set flag indicating whether a NotEmpty validator should be inserted when element is required
*
* @param bool $flag
* @return Zend_Form_Element
*/
public function setAutoInsertNotEmptyValidator($flag)
{
$this->_autoInsertNotEmptyValidator = (bool) $flag;
return $this;
}
/**
* Get flag indicating whether a NotEmpty validator should be inserted when element is required
*
* @return bool
*/
public function autoInsertNotEmptyValidator()
{
return $this->_autoInsertNotEmptyValidator;
}
/**
* Set element description
*
* @param string $description
* @return Zend_Form_Element
*/
public function setDescription($description)
{
$this->_description = (string) $description;
return $this;
}
/**
* Retrieve element description
*
* @return string
*/
public function getDescription()
{
return $this->_description;
}
/**
* Set 'allow empty' flag
*
* When the allow empty flag is enabled and the required flag is false, the
* element will validate with empty values.
*
* @param bool $flag
* @return Zend_Form_Element
*/
public function setAllowEmpty($flag)
{
$this->_allowEmpty = (bool) $flag;
return $this;
}
/**
* Get 'allow empty' flag
*
* @return bool
*/
public function getAllowEmpty()
{
return $this->_allowEmpty;
}
/**
* Set ignore flag (used when retrieving values at form level)
*
* @param bool $flag
* @return Zend_Form_Element
*/
public function setIgnore($flag)
{
$this->_ignore = (bool) $flag;
return $this;
}
/**
* Get ignore flag (used when retrieving values at form level)
*
* @return bool
*/
public function getIgnore()
{
return $this->_ignore;
}
/**
* Set flag indicating if element represents an array
*
* @param bool $flag
* @return Zend_Form_Element
*/
public function setIsArray($flag)
{
$this->_isArray = (bool) $flag;
return $this;
}
/**
* Is the element representing an array?
*
* @return bool
*/
public function isArray()
{
return $this->_isArray;
}
/**
* Set array to which element belongs
*
* @param string $array
* @return Zend_Form_Element
*/
public function setBelongsTo($array)
{
$array = $this->filterName($array, true);
if (!empty($array)) {
$this->_belongsTo = $array;
}
return $this;
}
/**
* Return array name to which element belongs
*
* @return string
*/
public function getBelongsTo()
{
return $this->_belongsTo;
}
/**
* Return element type
*
* @return string
*/
public function getType()
{
if (null === $this->_type) {
$this->_type = get_class($this);
}
return $this->_type;
}
/**
* Set element attribute
*
* @param string $name
* @param mixed $value
* @return Zend_Form_Element
* @throws Zend_Form_Exception for invalid $name values
*/
public function setAttrib($name, $value)
{
$name = (string) $name;
if ('_' == $name[0]) {
require_once 'Zend/Form/Exception.php';
throw new Zend_Form_Exception(sprintf('Invalid attribute "%s"; must not contain a leading underscore', $name));
}
if (null === $value) {
unset($this->$name);
} else {
$this->$name = $value;
}
return $this;
}
/**
* Set multiple attributes at once
*
* @param array $attribs
* @return Zend_Form_Element
*/
public function setAttribs(array $attribs)
{
foreach ($attribs as $key => $value) {
$this->setAttrib($key, $value);
}
return $this;
}
/**
* Retrieve element attribute
*
* @param string $name
* @return string
*/
public function getAttrib($name)
{
$name = (string) $name;
if (isset($this->$name)) {
return $this->$name;
}
return null;
}
/**
* Return all attributes
*
* @return array
*/
public function getAttribs()
{
$attribs = get_object_vars($this);
foreach ($attribs as $key => $value) {
if ('_' == substr($key, 0, 1)) {
unset($attribs[$key]);
}
}
return $attribs;
}
/**
* Overloading: retrieve object property
*
* Prevents access to properties beginning with '_'.
*
* @param string $key
* @return mixed
*/
public function __get($key)
{
if ('_' == $key[0]) {
require_once 'Zend/Form/Exception.php';
throw new Zend_Form_Exception(sprintf('Cannot retrieve value for protected/private property "%s"', $key));
}
if (!isset($this->$key)) {
return null;
}
return $this->$key;
}
/**
* Overloading: set object property
*
* @param string $key
* @param mixed $value
* @return voide
*/
public function __set($key, $value)
{
$this->setAttrib($key, $value);
}
/**
* Overloading: allow rendering specific decorators
*
* Call renderDecoratorName() to render a specific decorator.
*
* @param string $method
* @param array $args
* @return string
* @throws Zend_Form_Exception for invalid decorator or invalid method call
*/
public function __call($method, $args)
{
if ('render' == substr($method, 0, 6)) {
$decoratorName = substr($method, 6);
if (false !== ($decorator = $this->getDecorator($decoratorName))) {
$decorator->setElement($this);
$seed = '';
if (0 < count($args)) {
$seed = array_shift($args);
}
return $decorator->render($seed);
}
require_once 'Zend/Form/Element/Exception.php';
throw new Zend_Form_Element_Exception(sprintf('Decorator by name %s does not exist', $decoratorName));
}
require_once 'Zend/Form/Element/Exception.php';
throw new Zend_Form_Element_Exception(sprintf('Method %s does not exist', $method));
}
// Loaders
/**
* Set plugin loader to use for validator or filter chain
*
* @param Zend_Loader_PluginLoader_Interface $loader
* @param string $type 'decorator', 'filter', or 'validate'
* @return Zend_Form_Element
* @throws Zend_Form_Exception on invalid type
*/
public function setPluginLoader(Zend_Loader_PluginLoader_Interface $loader, $type)
{
$type = strtoupper($type);
switch ($type) {
case self::DECORATOR:
case self::FILTER:
case self::VALIDATE:
$this->_loaders[$type] = $loader;
return $this;
default:
require_once 'Zend/Form/Exception.php';
throw new Zend_Form_Exception(sprintf('Invalid type "%s" provided to setPluginLoader()', $type));
}
}
/**
* Retrieve plugin loader for validator or filter chain
*
* Instantiates with default rules if none available for that type. Use
* 'decorator', 'filter', or 'validate' for $type.
*
* @param string $type
* @return Zend_Loader_PluginLoader
* @throws Zend_Loader_Exception on invalid type.
*/
public function getPluginLoader($type)
{
$type = strtoupper($type);
switch ($type) {
case self::FILTER:
case self::VALIDATE:
$prefixSegment = ucfirst(strtolower($type));
$pathSegment = $prefixSegment;
case self::DECORATOR:
if (!isset($prefixSegment)) {
$prefixSegment = 'Form_Decorator';
$pathSegment = 'Form/Decorator';
}
if (!isset($this->_loaders[$type])) {
require_once 'Zend/Loader/PluginLoader.php';
$this->_loaders[$type] = new Zend_Loader_PluginLoader(
array('Zend_' . $prefixSegment . '_' => 'Zend/' . $pathSegment . '/')
);
}
return $this->_loaders[$type];
default:
require_once 'Zend/Form/Exception.php';
throw new Zend_Form_Exception(sprintf('Invalid type "%s" provided to getPluginLoader()', $type));
}
}
/**
* Add prefix path for plugin loader
*
* If no $type specified, assumes it is a base path for both filters and
* validators, and sets each according to the following rules:
* - decorators: $prefix = $prefix . '_Decorator'
* - filters: $prefix = $prefix . '_Filter'
* - validators: $prefix = $prefix . '_Validate'
*
* Otherwise, the path prefix is set on the appropriate plugin loader.
*
* @param string $path
* @return Zend_Form_Element
* @throws Zend_Form_Exception for invalid type
*/
public function addPrefixPath($prefix, $path, $type = null)
{
$type = strtoupper($type);
switch ($type) {
case self::DECORATOR:
case self::FILTER:
case self::VALIDATE:
$loader = $this->getPluginLoader($type);
$loader->addPrefixPath($prefix, $path);
return $this;
case null:
$prefix = rtrim($prefix, '_');
$path = rtrim($path, DIRECTORY_SEPARATOR);
foreach (array(self::DECORATOR, self::FILTER, self::VALIDATE) as $type) {
$cType = ucfirst(strtolower($type));
$pluginPath = $path . DIRECTORY_SEPARATOR . $cType . DIRECTORY_SEPARATOR;
$pluginPrefix = $prefix . '_' . $cType;
$loader = $this->getPluginLoader($type);
$loader->addPrefixPath($pluginPrefix, $pluginPath);
}
return $this;
default:
require_once 'Zend/Form/Exception.php';
throw new Zend_Form_Exception(sprintf('Invalid type "%s" provided to getPluginLoader()', $type));
}
}
/**
* Add many prefix paths at once
*
* @param array $spec
* @return Zend_Form_Element
*/
public function addPrefixPaths(array $spec)
{
if (isset($spec['prefix']) && isset($spec['path'])) {
return $this->addPrefixPath($spec['prefix'], $spec['path']);
}
foreach ($spec as $type => $paths) {
if (is_numeric($type) && is_array($paths)) {
$type = null;
if (isset($paths['prefix']) && isset($paths['path'])) {
if (isset($paths['type'])) {
$type = $paths['type'];
}
$this->addPrefixPath($paths['prefix'], $paths['path'], $type);
}
} elseif (!is_numeric($type)) {
if (!isset($paths['prefix']) || !isset($paths['path'])) {
foreach ($paths as $prefix => $spec) {
if (is_array($spec)) {
foreach ($spec as $path) {
if (!is_string($path)) {
continue;
}
$this->addPrefixPath($prefix, $path, $type);
}
} elseif (is_string($spec)) {
$this->addPrefixPath($prefix, $spec, $type);
}
}
} else {
$this->addPrefixPath($paths['prefix'], $paths['path'], $type);
}
}
}
return $this;
}
// Validation
/**
* Add validator to validation chain
*
* Note: will overwrite existing validators if they are of the same class.
*
* @param string|Zend_Validate_Interface $validator
* @param bool $breakChainOnFailure
* @param array $options
* @return Zend_Form_Element
* @throws Zend_Form_Exception if invalid validator type
*/
public function addValidator($validator, $breakChainOnFailure = false, $options = array())
{
if ($validator instanceof Zend_Validate_Interface) {
$name = get_class($validator);
if (!isset($validator->zfBreakChainOnFailure)) {
$validator->zfBreakChainOnFailure = $breakChainOnFailure;
}
} elseif (is_string($validator)) {
$name = $validator;
$validator = array(
'validator' => $validator,
'breakChainOnFailure' => $breakChainOnFailure,
'options' => $options,
);
} else {
require_once 'Zend/Form/Exception.php';
throw new Zend_Form_Exception('Invalid validator provided to addValidator; must be string or Zend_Validate_Interface');
}
$this->_validators[$name] = $validator;
return $this;
}
/**
* Add multiple validators
*
* @param array $validators
* @return Zend_Form_Element
*/
public function addValidators(array $validators)
{
foreach ($validators as $validatorInfo) {
if (is_string($validatorInfo)) {
$this->addValidator($validatorInfo);
} elseif ($validatorInfo instanceof Zend_Validate_Interface) {
$this->addValidator($validatorInfo);
} elseif (is_array($validatorInfo)) {
$argc = count($validatorInfo);
$breakChainOnFailure = false;
$options = array();
if (isset($validatorInfo['validator'])) {
$validator = $validatorInfo['validator'];
if (isset($validatorInfo['breakChainOnFailure'])) {
$breakChainOnFailure = $validatorInfo['breakChainOnFailure'];
}
if (isset($validatorInfo['options'])) {
$options = $validatorInfo['options'];
}
$this->addValidator($validator, $breakChainOnFailure, $options);
} else {
switch (true) {
case (0 == $argc):
break;
case (1 <= $argc):
$validator = array_shift($validatorInfo);
case (2 <= $argc):
$breakChainOnFailure = array_shift($validatorInfo);
case (3 <= $argc):
$options = array_shift($validatorInfo);
default:
$this->addValidator($validator, $breakChainOnFailure, $options);
break;
}
}
} else {
require_once 'Zend/Form/Exception.php';
throw new Zend_Form_Exception('Invalid validator passed to addValidators()');
}
}
return $this;
}
/**
* Set multiple validators, overwriting previous validators
*
* @param array $validators
* @return Zend_Form_Element
*/
public function setValidators(array $validators)
{
$this->clearValidators();
return $this->addValidators($validators);
}
/**
* Retrieve a single validator by name
*
* @param string $name
* @return Zend_Validate_Interface|false False if not found, validator otherwise
*/
public function getValidator($name)
{
if (!isset($this->_validators[$name])) {
$len = strlen($name);
foreach ($this->_validators as $localName => $validator) {
if ($len > strlen($localName)) {
continue;
}
if (0 === substr_compare($localName, $name, -$len, $len, true)) {
if (is_array($validator)) {
return $this->_loadValidator($validator);
}
return $validator;
}
}
return false;
}
if (is_array($this->_validators[$name])) {
return $this->_loadValidator($this->_validators[$name]);
}
return $this->_validators[$name];
}
/**
* Retrieve all validators
*
* @return array
*/
public function getValidators()
{
$validators = array();
foreach ($this->_validators as $key => $value) {
if ($value instanceof Zend_Validate_Interface) {
$validators[$key] = $value;
continue;
}
$validator = $this->_loadValidator($value);
$validators[get_class($validator)] = $validator;
}
return $validators;
}
/**
* Remove a single validator by name
*
* @param string $name
* @return bool
*/
public function removeValidator($name)
{
if (isset($this->_validators[$name])) {
unset($this->_validators[$name]);
} else {
$len = strlen($name);
foreach (array_keys($this->_validators) as $validator) {
if ($len > strlen($validator)) {
continue;
}
if (0 === substr_compare($validator, $name, -$len, $len, true)) {
unset($this->_validators[$validator]);
break;
}
}
}
return $this;
}
/**
* Clear all validators
*
* @return Zend_Form_Element
*/
public function clearValidators()
{
$this->_validators = array();
return $this;
}
/**
* Validate element value
*
* If a translation adapter is registered, any error messages will be
* translated according to the current locale, using the given error code;
* if no matching translation is found, the original message will be
* utilized.
*
* Note: The *filtered* value is validated.
*
* @param mixed $value
* @param mixed $context
* @return boolean
*/
public function isValid($value, $context = null)
{
$this->setValue($value);
$value = $this->getValue();
if ((('' === $value) || (null === $value))
&& !$this->isRequired()
&& $this->getAllowEmpty()
) {
return true;
}
if ($this->isRequired()
&& $this->autoInsertNotEmptyValidator()
&& !$this->getValidator('NotEmpty'))
{
$validators = $this->getValidators();
$notEmpty = array('validator' => 'NotEmpty', 'breakChainOnFailure' => true);
array_unshift($validators, $notEmpty);
$this->setValidators($validators);
}
$this->_messages = array();
$this->_errors = array();
$result = true;
$translator = $this->getTranslator();
$isArray = $this->isArray();
foreach ($this->getValidators() as $key => $validator) {
if (method_exists($validator, 'setTranslator')) {
$validator->setTranslator($translator);
}
if ($isArray && is_array($value)) {
$messages = array();
$errors = array();
foreach ($value as $val) {
if (!$validator->isValid($val, $context)) {
$result = false;
if ($this->_hasErrorMessages()) {
$messages = $this->_getErrorMessages();
$errors = $messages;
} else {
$messages = array_merge($messages, $validator->getMessages());
$errors = array_merge($errors, $validator->getErrors());
}
}
}
if ($result) {
continue;
}
} elseif ($validator->isValid($value, $context)) {
continue;
} else {
$result = false;
if ($this->_hasErrorMessages()) {
$messages = $this->_getErrorMessages();
$errors = $messages;
} else {
$messages = $validator->getMessages();
$errors = array_keys($messages);
}
}
$result = false;
$this->_messages = array_merge($this->_messages, $messages);
$this->_errors = array_merge($this->_errors, $errors);
if ($validator->zfBreakChainOnFailure) {
break;
}
}
return $result;
}
/**
* Add a custom error message to return in the event of failed validation
*
* @param string $message
* @return Zend_Form_Element
*/
public function addErrorMessage($message)
{
$this->_errorMessages[] = (string) $message;
return $this;
}
/**
* Add multiple custom error messages to return in the event of failed validation
*
* @param array $messages
* @return Zend_Form_Element
*/
public function addErrorMessages(array $messages)
{
foreach ($messages as $message) {
$this->addErrorMessage($message);
}
return $this;
}
/**
* Same as addErrorMessages(), but clears custom error message stack first
*
* @param array $messages
* @return Zend_Form_Element
*/
public function setErrorMessages(array $messages)
{
$this->clearErrorMessages();
return $this->addErrorMessages($messages);
}
/**
* Retrieve custom error messages
*
* @return array
*/
public function getErrorMessages()
{
return $this->_errorMessages;
}
/**
* Clear custom error messages stack
*
* @return Zend_Form_Element
*/
public function clearErrorMessages()
{
$this->_errorMessages = array();
return $this;
}
/**
* Mark the element as being in a failed validation state
*
* @return Zend_Form_Element
*/
public function markAsError()
{
$messages = $this->getMessages();
$customMessages = $this->_getErrorMessages();
$messages = $messages + $customMessages;
if (empty($messages)) {
$this->_isError = true;
} else {
$this->_messages = $messages;
}
return $this;
}
/**
* Add an error message and mark element as failed validation
*
* @param string $message
* @return Zend_Form_Element
*/
public function addError($message)
{
$this->addErrorMessage($message);
$this->markAsError();
return $this;
}
/**
* Add multiple error messages and flag element as failed validation
*
* @param array $messages
* @return Zend_Form_Element
*/
public function addErrors(array $messages)
{
foreach ($messages as $message) {
$this->addError($message);
}
return $this;
}
/**
* Overwrite any previously set error messages and flag as failed validation
*
* @param array $messages
* @return Zend_Form_Element
*/
public function setErrors(array $messages)
{
$this->clearErrorMessages();
return $this->addErrors($messages);
}
/**
* Are there errors registered?
*
* @return bool
*/
public function hasErrors()
{
return (!empty($this->_messages) || $this->_isError);
}
/**
* Retrieve validator chain errors
*
* @return array
*/
public function getErrors()
{
return $this->_errors;
}
/**
* Retrieve error messages
*
* @return array
*/
public function getMessages()
{
return $this->_messages;
}
// Filtering
/**
* Add a filter to the element
*
* @param string|Zend_Filter_Interface $filter
* @return Zend_Form_Element
*/
public function addFilter($filter, $options = array())
{
if ($filter instanceof Zend_Filter_Interface) {
$name = get_class($filter);
} elseif (is_string($filter)) {
$name = $filter;
$filter = array(
'filter' => $filter,
'options' => $options,
);
$this->_filters[$name] = $filter;
} else {
require_once 'Zend/Form/Exception.php';
throw new Zend_Form_Exception('Invalid filter provided to addFilter; must be string or Zend_Filter_Interface');
}
$this->_filters[$name] = $filter;
return $this;
}
/**
* Add filters to element
*
* @param array $filters
* @return Zend_Form_Element
*/
public function addFilters(array $filters)
{
foreach ($filters as $filterInfo) {
if (is_string($filterInfo)) {
$this->addFilter($filterInfo);
} elseif ($filterInfo instanceof Zend_Filter_Interface) {
$this->addFilter($filterInfo);
} elseif (is_array($filterInfo)) {
$argc = count($filterInfo);
$options = array();
if (isset($filterInfo['filter'])) {
$filter = $filterInfo['filter'];
if (isset($filterInfo['options'])) {
$options = $filterInfo['options'];
}
$this->addFilter($filter, $options);
} else {
switch (true) {
case (0 == $argc):
break;
case (1 <= $argc):
$filter = array_shift($filterInfo);
case (2 <= $argc):
$options = array_shift($filterInfo);
default:
$this->addFilter($filter, $options);
break;
}
}
} else {
require_once 'Zend/Form/Exception.php';
throw new Zend_Form_Exception('Invalid filter passed to addFilters()');
}
}
return $this;
}
/**
* Add filters to element, overwriting any already existing
*
* @param array $filters
* @return Zend_Form_Element
*/
public function setFilters(array $filters)
{
$this->clearFilters();
return $this->addFilters($filters);
}
/**
* Retrieve a single filter by name
*
* @param string $name
* @return Zend_Filter_Interface
*/
public function getFilter($name)
{
if (!isset($this->_filters[$name])) {
$len = strlen($name);
foreach ($this->_filters as $localName => $filter) {
if ($len > strlen($localName)) {
continue;
}
if (0 === substr_compare($localName, $name, -$len, $len, true)) {
if (is_array($filter)) {
return $this->_loadFilter($filter);
}
return $filter;
}
}
return false;
}
if (is_array($this->_filters[$name])) {
return $this->_loadFilter($this->_filters[$name]);
}
return $this->_filters[$name];
}
/**
* Get all filters
*
* @return array
*/
public function getFilters()
{
$filters = array();
foreach ($this->_filters as $key => $value) {
if ($value instanceof Zend_Filter_Interface) {
$filters[$key] = $value;
continue;
}
$filter = $this->_loadFilter($value);
$filters[get_class($filter)] = $filter;
}
return $filters;
}
/**
* Remove a filter by name
*
* @param string $name
* @return Zend_Form_Element
*/
public function removeFilter($name)
{
if (isset($this->_filters[$name])) {
unset($this->_filters[$name]);
} else {
$len = strlen($name);
foreach (array_keys($this->_filters) as $filter) {
if ($len > strlen($filter)) {
continue;
}
if (0 === substr_compare($filter, $name, -$len, $len, true)) {
unset($this->_filters[$filter]);
break;
}
}
}
return $this;
}
/**
* Clear all filters
*
* @return Zend_Form_Element
*/
public function clearFilters()
{
$this->_filters = array();
return $this;
}
// Rendering
/**
* Set view object
*
* @param Zend_View_Interface $view
* @return Zend_Form_Element
*/
public function setView(Zend_View_Interface $view = null)
{
$this->_view = $view;
return $this;
}
/**
* Retrieve view object
*
* Retrieves from ViewRenderer if none previously set.
*
* @return null|Zend_View_Interface
*/
public function getView()
{
if (null === $this->_view) {
require_once 'Zend/Controller/Action/HelperBroker.php';
$viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper('viewRenderer');
$this->setView($viewRenderer->view);
}
return $this->_view;
}
/**
* Instantiate a decorator based on class name or class name fragment
*
* @param string $name
* @param null|array $options
* @return Zend_Form_Decorator_Interface
*/
protected function _getDecorator($name, $options)
{
$class = $this->getPluginLoader(self::DECORATOR)->load($name);
if (null === $options) {
$decorator = new $class;
} else {
$decorator = new $class($options);
}
return $decorator;
}
/**
* Add a decorator for rendering the element
*
* @param string|Zend_Form_Decorator_Interface $decorator
* @param array|Zend_Config $options Options with which to initialize decorator
* @return Zend_Form_Element
*/
public function addDecorator($decorator, $options = null)
{
if ($decorator instanceof Zend_Form_Decorator_Interface) {
$name = get_class($decorator);
} elseif (is_string($decorator)) {
$name = $decorator;
$decorator = array(
'decorator' => $name,
'options' => $options,
);
} elseif (is_array($decorator)) {
foreach ($decorator as $name => $spec) {
break;
}
if (is_numeric($name)) {
require_once 'Zend/Form/Exception.php';
throw new Zend_Form_Exception('Invalid alias provided to addDecorator; must be alphanumeric string');
}
if (is_string($spec)) {
$decorator = array(
'decorator' => $spec,
'options' => $options,
);
} elseif ($spec instanceof Zend_Form_Decorator_Interface) {
$decorator = $spec;
}
} else {
require_once 'Zend/Form/Exception.php';
throw new Zend_Form_Exception('Invalid decorator provided to addDecorator; must be string or Zend_Form_Decorator_Interface');
}
$this->_decorators[$name] = $decorator;
return $this;
}
/**
* Add many decorators at once
*
* @param array $decorators
* @return Zend_Form_Element
*/
public function addDecorators(array $decorators)
{
foreach ($decorators as $decoratorInfo) {
if (is_string($decoratorInfo)) {
$this->addDecorator($decoratorInfo);
} elseif ($decoratorInfo instanceof Zend_Form_Decorator_Interface) {
$this->addDecorator($decoratorInfo);
} elseif (is_array($decoratorInfo)) {
$argc = count($decoratorInfo);
$options = array();
if (isset($decoratorInfo['decorator'])) {
$decorator = $decoratorInfo['decorator'];
if (isset($decoratorInfo['options'])) {
$options = $decoratorInfo['options'];
}
$this->addDecorator($decorator, $options);
} else {
switch (true) {
case (0 == $argc):
break;
case (1 <= $argc):
$decorator = array_shift($decoratorInfo);
case (2 <= $argc):
$options = array_shift($decoratorInfo);
default:
$this->addDecorator($decorator, $options);
break;
}
}
} else {
require_once 'Zend/Form/Exception.php';
throw new Zend_Form_Exception('Invalid decorator passed to addDecorators()');
}
}
return $this;
}
/**
* Overwrite all decorators
*
* @param array $decorators
* @return Zend_Form_Element
*/
public function setDecorators(array $decorators)
{
$this->clearDecorators();
return $this->addDecorators($decorators);
}
/**
* Retrieve a registered decorator
*
* @param string $name
* @return false|Zend_Form_Decorator_Abstract
*/
public function getDecorator($name)
{
if (!isset($this->_decorators[$name])) {
$len = strlen($name);
foreach ($this->_decorators as $localName => $decorator) {
if ($len > strlen($localName)) {
continue;
}
if (0 === substr_compare($localName, $name, -$len, $len, true)) {
if (is_array($decorator)) {
return $this->_loadDecorator($decorator, $localName);
}
return $decorator;
}
}
return false;
}
if (is_array($this->_decorators[$name])) {
return $this->_loadDecorator($this->_decorators[$name], $name);
}
return $this->_decorators[$name];
}
/**
* Retrieve all decorators
*
* @return array
*/
public function getDecorators()
{
foreach ($this->_decorators as $key => $value) {
if (is_array($value)) {
$this->_loadDecorator($value, $key);
}
}
return $this->_decorators;
}
/**
* Remove a single decorator
*
* @param string $name
* @return bool
*/
public function removeDecorator($name)
{
if (isset($this->_decorators[$name])) {
unset($this->_decorators[$name]);
} else {
$len = strlen($name);
foreach (array_keys($this->_decorators) as $decorator) {
if ($len > strlen($decorator)) {
continue;
}
if (0 === substr_compare($decorator, $name, -$len, $len, true)) {
unset($this->_decorators[$decorator]);
break;
}
}
}
return $this;
}
/**
* Clear all decorators
*
* @return Zend_Form_Element
*/
public function clearDecorators()
{
$this->_decorators = array();
return $this;
}
/**
* Render form element
*
* @param Zend_View_Interface $view
* @return string
*/
public function render(Zend_View_Interface $view = null)
{
if (null !== $view) {
$this->setView($view);
}
$content = '';
foreach ($this->getDecorators() as $decorator) {
$decorator->setElement($this);
$content = $decorator->render($content);
}
return $content;
}
/**
* String representation of form element
*
* Proxies to {@link render()}.
*
* @return string
*/
public function __toString()
{
try {
$return = $this->render();
return $return;
} catch (Exception $e) {
trigger_error($e->getMessage(), E_USER_WARNING);
return '';
}
}
/**
* Lazy-load a filter
*
* @param array $filter
* @return Zend_Filter_Interface
*/
protected function _loadFilter(array $filter)
{
$origName = $filter['filter'];
$name = $this->getPluginLoader(self::FILTER)->load($filter['filter']);
if (array_key_exists($name, $this->_filters)) {
require_once 'Zend/Form/Exception.php';
throw new Zend_Form_Exception(sprintf('Filter instance already exists for filter "%s"', $origName));
}
if (empty($filter['options'])) {
$instance = new $name;
} else {
$r = new ReflectionClass($name);
if ($r->hasMethod('__construct')) {
$instance = $r->newInstanceArgs((array) $filter['options']);
} else {
$instance = $r->newInstance();
}
}
if ($origName != $name) {
$filterNames = array_keys($this->_filters);
$order = array_flip($filterNames);
$order[$name] = $order[$origName];
$filtersExchange = array();
unset($order[$origName]);
asort($order);
foreach ($order as $key => $index) {
if ($key == $name) {
$filtersExchange[$key] = $instance;
continue;
}
$filtersExchange[$key] = $this->_filters[$key];
}
$this->_filters = $filtersExchange;
} else {
$this->_filters[$name] = $instance;
}
return $instance;
}
/**
* Lazy-load a validator
*
* @param array $validator Validator definition
* @return Zend_Validate_Interface
*/
protected function _loadValidator(array $validator)
{
$origName = $validator['validator'];
$name = $this->getPluginLoader(self::VALIDATE)->load($validator['validator']);
if (array_key_exists($name, $this->_validators)) {
require_once 'Zend/Form/Exception.php';
throw new Zend_Form_Exception(sprintf('Validator instance already exists for validator "%s"', $origName));
}
if (empty($validator['options'])) {
$instance = new $name;
} else {
$messages = false;
if (isset($validator['options']['messages'])) {
$messages = $validator['options']['messages'];
unset($validator['options']['messages']);
}
$r = new ReflectionClass($name);
if ($r->hasMethod('__construct')) {
$instance = $r->newInstanceArgs((array) $validator['options']);
} else {
$instance = $r->newInstance();
}
if ($messages) {
if (is_array($messages)) {
$instance->setMessages($messages);
} elseif (is_string($messages)) {
$instance->setMessage($messages);
}
}
}
$instance->zfBreakChainOnFailure = $validator['breakChainOnFailure'];
if ($origName != $name) {
$validatorNames = array_keys($this->_validators);
$order = array_flip($validatorNames);
$order[$name] = $order[$origName];
$validatorsExchange = array();
unset($order[$origName]);
asort($order);
foreach ($order as $key => $index) {
if ($key == $name) {
$validatorsExchange[$key] = $instance;
continue;
}
$validatorsExchange[$key] = $this->_validators[$key];
}
$this->_validators = $validatorsExchange;
} else {
$this->_validators[$name] = $instance;
}
return $instance;
}
/**
* Lazy-load a decorator
*
* @param array $decorator Decorator type and options
* @param mixed $name Decorator name or alias
* @return Zend_Form_Decorator_Interface
*/
protected function _loadDecorator(array $decorator, $name)
{
$sameName = false;
if ($name == $decorator['decorator']) {
$sameName = true;
}
$instance = $this->_getDecorator($decorator['decorator'], $decorator['options']);
if ($sameName) {
$newName = get_class($instance);
$decoratorNames = array_keys($this->_decorators);
$order = array_flip($decoratorNames);
$order[$newName] = $order[$name];
$decoratorsExchange = array();
unset($order[$name]);
asort($order);
foreach ($order as $key => $index) {
if ($key == $newName) {
$decoratorsExchange[$key] = $instance;
continue;
}
$decoratorsExchange[$key] = $this->_decorators[$key];
}
$this->_decorators = $decoratorsExchange;
} else {
$this->_decorators[$name] = $instance;
}
return $instance;
}
/**
* Retrieve error messages and perform translation and value substitution
*
* @return array
*/
protected function _getErrorMessages()
{
$translator = $this->getTranslator();
$messages = $this->getErrorMessages();
$value = $this->getValue();
foreach ($messages as $key => $message) {
if (null !== $translator) {
$message = $translator->translate($message);
}
if ($this->isArray() || is_array($value)) {
$aggregateMessages = array();
foreach ($value as $val) {
$aggregateMessages[] = str_replace('%value%', $val, $message);
}
$messages[$key] = $aggregateMessages;
} else {
$messages[$key] = str_replace('%value%', $value, $message);
}
}
return $messages;
}
/**
* Are there custom error messages registered?
*
* @return bool
*/
protected function _hasErrorMessages()
{
return !empty($this->_errorMessages);
}
}
home/karenpetzb/library/Zend/Pdf/Element.php 0000604 00000007752 15071304432 0015026 0 ustar 00 <?php
/**
* Zend Framework
*
* LICENSE
*
* This source file is subject to the new BSD license that is bundled
* with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://framework.zend.com/license/new-bsd
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@zend.com so we can send you a copy immediately.
*
* @package Zend_Pdf
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
/** Zend_Pdf_Element */
require_once 'Zend/Pdf/Element.php';
/** Zend_Pdf_Element_Object */
require_once 'Zend/Pdf/Element/Object.php';
/**
* PDF file element implementation
*
* @package Zend_Pdf
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
abstract class Zend_Pdf_Element
{
const TYPE_BOOL = 1;
const TYPE_NUMERIC = 2;
const TYPE_STRING = 3;
const TYPE_NAME = 4;
const TYPE_ARRAY = 5;
const TYPE_DICTIONARY = 6;
const TYPE_STREAM = 7;
const TYPE_NULL = 11;
/**
* Reference to the top level indirect object, which contains this element.
*
* @var Zend_Pdf_Element_Object
*/
private $_parentObject = null;
/**
* Return type of the element.
* See ZPdfPDFConst for possible values
*
* @return integer
*/
abstract public function getType();
/**
* Convert element to a string, which can be directly
* written to a PDF file.
*
* $factory parameter defines operation context.
*
* @param Zend_Pdf_Factory $factory
* @return string
*/
abstract public function toString($factory = null);
/**
* Set top level parent indirect object.
*
* @param Zend_Pdf_Element_Object $parent
*/
public function setParentObject(Zend_Pdf_Element_Object &$parent)
{
$this->_parentObject = &$parent;
}
/**
* Get top level parent indirect object.
*
* @return Zend_Pdf_Element_Object
*/
public function getParentObject()
{
return $this->_parentObject;
}
/**
* Mark object as modified, to include it into new PDF file segment.
*
* We don't automate this action to keep control on PDF update process.
* All new objects are treated as "modified" automatically.
*/
public function touch()
{
if ($this->_parentObject !== null) {
$this->_parentObject->touch();
}
}
/**
* Clean up resources, used by object
*/
public function cleanUp()
{
// Do nothing
}
/**
* Convert PDF element to PHP type.
*
* @return mixed
*/
public function toPhp()
{
return $this->value;
}
/**
* Convert PHP value into PDF element.
*
* @param mixed $input
* @return Zend_Pdf_Element
*/
public static function phpToPdf($input)
{
if (is_numeric($input)) {
return new Zend_Pdf_Element_Numeric($input);
} else if (is_bool($input)) {
return new Zend_Pdf_Element_Boolean($input);
} else if (is_array($input)) {
$pdfElementsArray = array();
$isDictionary = false;
foreach ($input as $key => $value) {
if (is_string($key)) {
$isDictionary = true;
}
$pdfElementsArray[$key] = Zend_Pdf_Element::phpToPdf($value);
}
if ($isDictionary) {
return new Zend_Pdf_Element_Dictionary($pdfElementsArray);
} else {
return new Zend_Pdf_Element_Array($pdfElementsArray);
}
} else {
return new Zend_Pdf_Element_String((string)$input);
}
}
}
home/karenpetzb/library/Zend/InfoCard/Xml/Element.php 0000604 00000007073 15071454676 0016556 0 ustar 00 <?php
/**
* Zend Framework
*
* LICENSE
*
* This source file is subject to the new BSD license that is bundled
* with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://framework.zend.com/license/new-bsd
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@zend.com so we can send you a copy immediately.
*
* @category Zend
* @package Zend_InfoCard
* @subpackage Zend_InfoCard_Xml
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
* @version $Id: Element.php 9094 2008-03-30 18:36:55Z thomas $
*/
/**
* Zend_InfoCard_Xml_Exception
*/
require_once 'Zend/InfoCard/Xml/Exception.php';
/**
* Zend_InfoCard_Xml_Element_Interface
*/
require_once 'Zend/InfoCard/Xml/Element/Interface.php';
/**
* Zend_Loader
*/
require_once 'Zend/Loader.php';
/**
* An abstract class representing a an XML data block
*
* @category Zend
* @package Zend_InfoCard
* @subpackage Zend_InfoCard_Xml
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
abstract class Zend_InfoCard_Xml_Element
extends SimpleXMLElement
implements Zend_InfoCard_Xml_Element_Interface
{
/**
* Convert the object to a string by displaying its XML content
*
* @return string an XML representation of the object
*/
public function __toString()
{
return $this->asXML();
}
/**
* Converts an XML Element object into a DOM object
*
* @throws Zend_InfoCard_Xml_Exception
* @param Zend_InfoCard_Xml_Element $e The object to convert
* @return DOMElement A DOMElement representation of the same object
*/
static public function convertToDOM(Zend_InfoCard_Xml_Element $e)
{
$dom = dom_import_simplexml($e);
if(!($dom instanceof DOMElement)) {
// Zend_InfoCard_Xml_Element exntes SimpleXMLElement, so this should *never* fail
// @codeCoverageIgnoreStart
throw new Zend_InfoCard_Xml_Exception("Failed to convert between SimpleXML and DOM");
// @codeCoverageIgnoreEnd
}
return $dom;
}
/**
* Converts a DOMElement object into the specific class
*
* @throws Zend_InfoCard_Xml_Exception
* @param DOMElement $e The DOMElement object to convert
* @param string $classname The name of the class to convert it to (must inhert from Zend_InfoCard_Xml_Element)
* @return Zend_InfoCard_Xml_Element a Xml Element object from the DOM element
*/
static public function convertToObject(DOMElement $e, $classname)
{
Zend_Loader::loadClass($classname);
$reflection = new ReflectionClass($classname);
if(!$reflection->isSubclassOf('Zend_InfoCard_Xml_Element')) {
throw new Zend_InfoCard_Xml_Exception("DOM element must be converted to an instance of Zend_InfoCard_Xml_Element");
}
$sxe = simplexml_import_dom($e, $classname);
if(!($sxe instanceof Zend_InfoCard_Xml_Element)) {
// Since we just checked to see if this was a subclass of Zend_infoCard_Xml_Element this shoudl never fail
// @codeCoverageIgnoreStart
throw new Zend_InfoCard_Xml_Exception("Failed to convert between DOM and SimpleXML");
// @codeCoverageIgnoreEnd
}
return $sxe;
}
}
home/karenpetzb/library/Zend/Feed/Element.php 0000604 00000026342 15071464650 0015165 0 ustar 00 <?php
/**
* Zend Framework
*
* LICENSE
*
* This source file is subject to the new BSD license that is bundled
* with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://framework.zend.com/license/new-bsd
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@zend.com so we can send you a copy immediately.
*
* @category Zend
* @package Zend_Feed
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
* @version $Id: Element.php 8064 2008-02-16 10:58:39Z thomas $
*/
/**
* Wraps a DOMElement allowing for SimpleXML-like access to attributes.
*
* @category Zend
* @package Zend_Feed
* @copyright Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
class Zend_Feed_Element implements ArrayAccess
{
/**
* @var DOMElement
*/
protected $_element;
/**
* @var Zend_Feed_Element
*/
protected $_parentElement;
/**
* @var boolean
*/
protected $_appended = true;
/**
* Zend_Feed_Element constructor.
*
* @param DOMElement $element The DOM element we're encapsulating.
* @return void
*/
public function __construct($element = null)
{
$this->_element = $element;
}
/**
* Get a DOM representation of the element
*
* Returns the underlying DOM object, which can then be
* manipulated with full DOM methods.
*
* @return DOMDocument
*/
public function getDOM()
{
return $this->_element;
}
/**
* Update the object from a DOM element
*
* Take a DOMElement object, which may be originally from a call
* to getDOM() or may be custom created, and use it as the
* DOM tree for this Zend_Feed_Element.
*
* @param DOMElement $element
* @return void
*/
public function setDOM(DOMElement $element)
{
$this->_element = $this->_element->ownerDocument->importNode($element, true);
}
/**
* Set the parent element of this object to another
* Zend_Feed_Element.
*
* @param Zend_Feed_Element $element
* @return void
*/
public function setParent(Zend_Feed_Element $element)
{
$this->_parentElement = $element;
$this->_appended = false;
}
/**
* Appends this element to its parent if necessary.
*
* @return void
*/
protected function ensureAppended()
{
if (!$this->_appended) {
$this->_parentElement->getDOM()->appendChild($this->_element);
$this->_appended = true;
$this->_parentElement->ensureAppended();
}
}
/**
* Get an XML string representation of this element
*
* Returns a string of this element's XML, including the XML
* prologue.
*
* @return string
*/
public function saveXml()
{
// Return a complete document including XML prologue.
$doc = new DOMDocument($this->_element->ownerDocument->version,
$this->_element->ownerDocument->actualEncoding);
$doc->appendChild($doc->importNode($this->_element, true));
return $doc->saveXML();
}
/**
* Get the XML for only this element
*
* Returns a string of this element's XML without prologue.
*
* @return string
*/
public function saveXmlFragment()
{
return $this->_element->ownerDocument->saveXML($this->_element);
}
/**
* Map variable access onto the underlying entry representation.
*
* Get-style access returns a Zend_Feed_Element representing the
* child element accessed. To get string values, use method syntax
* with the __call() overriding.
*
* @param string $var The property to access.
* @return mixed
*/
public function __get($var)
{
$nodes = $this->_children($var);
$length = count($nodes);
if ($length == 1) {
return new Zend_Feed_Element($nodes[0]);
} elseif ($length > 1) {
return array_map(create_function('$e', 'return new Zend_Feed_Element($e);'), $nodes);
} else {
// When creating anonymous nodes for __set chaining, don't
// call appendChild() on them. Instead we pass the current
// element to them as an extra reference; the child is
// then responsible for appending itself when it is
// actually set. This way "if ($foo->bar)" doesn't create
// a phantom "bar" element in our tree.
if (strpos($var, ':') !== false) {
list($ns, $elt) = explode(':', $var, 2);
$node = $this->_element->ownerDocument->createElementNS(Zend_Feed::lookupNamespace($ns), $elt);
} else {
$node = $this->_element->ownerDocument->createElement($var);
}
$node = new self($node);
$node->setParent($this);
return $node;
}
}
/**
* Map variable sets onto the underlying entry representation.
*
* @param string $var The property to change.
* @param string $val The property's new value.
* @return void
* @throws Zend_Feed_Exception
*/
public function __set($var, $val)
{
$this->ensureAppended();
$nodes = $this->_children($var);
if (!$nodes) {
if (strpos($var, ':') !== false) {
list($ns, $elt) = explode(':', $var, 2);
$node = $this->_element->ownerDocument->createElementNS(Zend_Feed::lookupNamespace($ns), $var, $val);
$this->_element->appendChild($node);
} else {
$node = $this->_element->ownerDocument->createElement($var, $val);
$this->_element->appendChild($node);
}
} elseif (count($nodes) > 1) {
/**
* @see Zend_Feed_Exception
*/
require_once 'Zend/Feed/Exception.php';
throw new Zend_Feed_Exception('Cannot set the value of multiple tags simultaneously.');
} else {
$nodes[0]->nodeValue = $val;
}
}
/**
* Map isset calls onto the underlying entry representation.
*
* @param string $var
* @return boolean
*/
public function __isset($var)
{
// Look for access of the form {ns:var}. We don't use
// _children() here because we can break out of the loop
// immediately once we find something.
if (strpos($var, ':') !== false) {
list($ns, $elt) = explode(':', $var, 2);
foreach ($this->_element->childNodes as $child) {
if ($child->localName == $elt && $child->prefix == $ns) {
return true;
}
}
} else {
foreach ($this->_element->childNodes as $child) {
if ($child->localName == $var) {
return true;
}
}
}
}
/**
* Get the value of an element with method syntax.
*
* Map method calls to get the string value of the requested
* element. If there are multiple elements that match, this will
* return an array of those objects.
*
* @param string $var The element to get the string value of.
* @param mixed $unused This parameter is not used.
* @return mixed The node's value, null, or an array of nodes.
*/
public function __call($var, $unused)
{
$nodes = $this->_children($var);
if (!$nodes) {
return null;
} elseif (count($nodes) > 1) {
return $nodes;
} else {
return $nodes[0]->nodeValue;
}
}
/**
* Remove all children matching $var.
*
* @param string $var
* @return void
*/
public function __unset($var)
{
$nodes = $this->_children($var);
foreach ($nodes as $node) {
$parent = $node->parentNode;
$parent->removeChild($node);
}
}
/**
* Returns the nodeValue of this element when this object is used
* in a string context.
*
* @return string
*/
public function __toString()
{
return $this->_element->nodeValue;
}
/**
* Finds children with tagnames matching $var
*
* Similar to SimpleXML's children() method.
*
* @param string $var Tagname to match, can be either namespace:tagName or just tagName.
* @return array
*/
protected function _children($var)
{
$found = array();
// Look for access of the form {ns:var}.
if (strpos($var, ':') !== false) {
list($ns, $elt) = explode(':', $var, 2);
foreach ($this->_element->childNodes as $child) {
if ($child->localName == $elt && $child->prefix == $ns) {
$found[] = $child;
}
}
} else {
foreach ($this->_element->childNodes as $child) {
if ($child->localName == $var) {
$found[] = $child;
}
}
}
return $found;
}
/**
* Required by the ArrayAccess interface.
*
* @param string $offset
* @return boolean
*/
public function offsetExists($offset)
{
if (strpos($offset, ':') !== false) {
list($ns, $attr) = explode(':', $offset, 2);
return $this->_element->hasAttributeNS(Zend_Feed::lookupNamespace($ns), $attr);
} else {
return $this->_element->hasAttribute($offset);
}
}
/**
* Required by the ArrayAccess interface.
*
* @param string $offset
* @return string
*/
public function offsetGet($offset)
{
if (strpos($offset, ':') !== false) {
list($ns, $attr) = explode(':', $offset, 2);
return $this->_element->getAttributeNS(Zend_Feed::lookupNamespace($ns), $attr);
} else {
return $this->_element->getAttribute($offset);
}
}
/**
* Required by the ArrayAccess interface.
*
* @param string $offset
* @param string $value
* @return string
*/
public function offsetSet($offset, $value)
{
$this->ensureAppended();
if (strpos($offset, ':') !== false) {
list($ns, $attr) = explode(':', $offset, 2);
return $this->_element->setAttributeNS(Zend_Feed::lookupNamespace($ns), $attr, $value);
} else {
return $this->_element->setAttribute($offset, $value);
}
}
/**
* Required by the ArrayAccess interface.
*
* @param string $offset
* @return boolean
*/
public function offsetUnset($offset)
{
if (strpos($offset, ':') !== false) {
list($ns, $attr) = explode(':', $offset, 2);
return $this->_element->removeAttributeNS(Zend_Feed::lookupNamespace($ns), $attr);
} else {
return $this->_element->removeAttribute($offset);
}
}
}