my-simon 0.0.0 → 0.0.1

data/www/lib/php/plugins/php-activerecord/lib/SQLBuilder.php

@@ -0,0 +1,396 @@
+<?php
+/**
+ * @package ActiveRecord
+ */
+namespace ActiveRecord;
+
+/**
+ * Helper class for building sql statements progmatically.
+ *
+ * @package ActiveRecord
+ */
+class SQLBuilder
+{
+	private $connection;
+	private $operation = 'SELECT';
+	private $table;
+	private $select = '*';
+	private $joins;
+	private $order;
+	private $limit;
+	private $offset;
+	private $group;
+	private $having;
+
+	// for where
+	private $where;
+	private $where_values = array();
+
+	// for insert/update
+	private $data;
+	private $sequence;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param Connection $connection A database connection object
+	 * @param string $table Name of a table
+	 * @return SQLBuilder
+	 * @throws ActiveRecordException if connection was invalid
+	 */
+	public function __construct($connection, $table)
+	{
+		if (!$connection)
+			throw new ActiveRecordException('A valid database connection is required.');
+
+		$this->connection	= $connection;
+		$this->table		= $table;
+	}
+
+	/**
+	 * Returns the SQL string.
+	 *
+	 * @return string
+	 */
+	public function __toString()
+	{
+		return $this->to_s();
+	}
+
+	/**
+	 * Returns the SQL string.
+	 *
+	 * @see __toString
+	 * @return string
+	 */
+	public function to_s()
+	{
+		$func = 'build_' . strtolower($this->operation);
+		return $this->$func();
+	}
+
+	/**
+	 * Returns the bind values.
+	 *
+	 * @return array
+	 */
+	public function bind_values()
+	{
+		$ret = array();
+
+		if ($this->data)
+			$ret = array_values($this->data);
+
+		if ($this->get_where_values())
+			$ret = array_merge($ret,$this->get_where_values());
+
+		return array_flatten($ret);
+	}
+
+	public function get_where_values()
+	{
+		return $this->where_values;
+	}
+
+	public function where(/* (conditions, values) || (hash) */)
+	{
+		$this->apply_where_conditions(func_get_args());
+		return $this;
+	}
+
+	public function order($order)
+	{
+		$this->order = $order;
+		return $this;
+	}
+
+	public function group($group)
+	{
+		$this->group = $group;
+		return $this;
+	}
+
+	public function having($having)
+	{
+		$this->having = $having;
+		return $this;
+	}
+
+	public function limit($limit)
+	{
+		$this->limit = intval($limit);
+		return $this;
+	}
+
+	public function offset($offset)
+	{
+		$this->offset = intval($offset);
+		return $this;
+	}
+
+	public function select($select)
+	{
+		$this->operation = 'SELECT';
+		$this->select = $select;
+		return $this;
+	}
+
+	public function joins($joins)
+	{
+		$this->joins = $joins;
+		return $this;
+	}
+
+	public function insert($hash, $pk=null, $sequence_name=null)
+	{
+		if (!is_hash($hash))
+			throw new ActiveRecordException('Inserting requires a hash.');
+
+		$this->operation = 'INSERT';
+		$this->data = $hash;
+
+		if ($pk && $sequence_name)
+			$this->sequence = array($pk,$sequence_name);
+
+		return $this;
+	}
+
+	public function update($hash)
+	{
+		if (!is_hash($hash))
+			throw new ActiveRecordException('Updating requires a hash.');
+
+		$this->operation = 'UPDATE';
+		$this->data = $hash;
+		return $this;
+	}
+
+	public function delete()
+	{
+		$this->operation = 'DELETE';
+		$this->apply_where_conditions(func_get_args());
+		return $this;
+	}
+
+	/**
+	 * Reverses an order clause.
+	 */
+	public static function reverse_order($order)
+	{
+		if (!trim($order))
+			return $order;
+
+		$parts = explode(',',$order);
+
+		for ($i=0,$n=count($parts); $i<$n; ++$i)
+		{
+			$v = strtolower($parts[$i]);
+
+			if (strpos($v,' asc') !== false)
+				$parts[$i] = preg_replace('/asc/i','DESC',$parts[$i]);
+			elseif (strpos($v,' desc') !== false)
+				$parts[$i] = preg_replace('/desc/i','ASC',$parts[$i]);
+			else
+				$parts[$i] .= ' DESC';
+		}
+		return join(',',$parts);
+	}
+
+	/**
+	 * Converts a string like "id_and_name_or_z" into a conditions value like array("id=? AND name=? OR z=?", values, ...).
+	 *
+	 * @param Connection $connection
+	 * @param $name Underscored string
+	 * @param $values Array of values for the field names. This is used
+	 *   to determine what kind of bind marker to use: =?, IN(?), IS NULL
+	 * @param $map A hash of "mapped_column_name" => "real_column_name"
+	 * @return A conditions array in the form array(sql_string, value1, value2,...)
+	 */
+	public static function create_conditions_from_underscored_string(Connection $connection, $name, &$values=array(), &$map=null)
+	{
+		if (!$name)
+			return null;
+
+		$parts = preg_split('/(_and_|_or_)/i',$name,-1,PREG_SPLIT_DELIM_CAPTURE);
+		$num_values = count($values);
+		$conditions = array('');
+
+		for ($i=0,$j=0,$n=count($parts); $i<$n; $i+=2,++$j)
+		{
+			if ($i >= 2)
+				$conditions[0] .= preg_replace(array('/_and_/i','/_or_/i'),array(' AND ',' OR '),$parts[$i-1]);
+
+			if ($j < $num_values)
+			{
+				if (!is_null($values[$j]))
+				{
+					$bind = is_array($values[$j]) ? ' IN(?)' : '=?';
+					$conditions[] = $values[$j];
+				}
+				else
+					$bind = ' IS NULL';
+			}
+			else
+				$bind = ' IS NULL';
+
+			// map to correct name if $map was supplied
+			$name = $map && isset($map[$parts[$i]]) ? $map[$parts[$i]] : $parts[$i];
+
+			$conditions[0] .= $connection->quote_name($name) . $bind;
+		}
+		return $conditions;
+	}
+
+	/**
+	 * Like create_conditions_from_underscored_string but returns a hash of name => value array instead.
+	 *
+	 * @param string $name A string containing attribute names connected with _and_ or _or_
+	 * @param $args Array of values for each attribute in $name
+	 * @param $map A hash of "mapped_column_name" => "real_column_name"
+	 * @return array A hash of array(name => value, ...)
+	 */
+	public static function create_hash_from_underscored_string($name, &$values=array(), &$map=null)
+	{
+		$parts = preg_split('/(_and_|_or_)/i',$name);
+		$hash = array();
+
+		for ($i=0,$n=count($parts); $i<$n; ++$i)
+		{
+			// map to correct name if $map was supplied
+			$name = $map && isset($map[$parts[$i]]) ? $map[$parts[$i]] : $parts[$i];
+			$hash[$name] = $values[$i];
+		}
+		return $hash;
+	}
+
+	/**
+	 * prepends table name to hash of field names to get around ambiguous fields when SQL builder
+	 * has joins
+	 *
+	 * @param array $hash
+	 * @return array $new
+	 */
+	private function prepend_table_name_to_fields($hash=array())
+	{
+		$new = array();
+		$table = $this->connection->quote_name($this->table);
+
+		foreach ($hash as $key => $value)
+		{
+			$k = $this->connection->quote_name($key);
+			$new[$table.'.'.$k] = $value;
+		}
+
+		return $new;
+	}
+
+	private function apply_where_conditions($args)
+	{
+		require_once 'Expressions.php';
+		$num_args = count($args);
+
+		if ($num_args == 1 && is_hash($args[0]))
+		{
+			$hash = is_null($this->joins) ? $args[0] : $this->prepend_table_name_to_fields($args[0]);
+			$e = new Expressions($this->connection,$hash);
+			$this->where = $e->to_s();
+			$this->where_values = array_flatten($e->values());
+		}
+		elseif ($num_args > 0)
+		{
+			// if the values has a nested array then we'll need to use Expressions to expand the bind marker for us
+			$values = array_slice($args,1);
+
+			foreach ($values as $name => &$value)
+			{
+				if (is_array($value))
+				{
+					$e = new Expressions($this->connection,$args[0]);
+					$e->bind_values($values);
+					$this->where = $e->to_s();
+					$this->where_values = array_flatten($e->values());
+					return;
+				}
+			}
+
+			// no nested array so nothing special to do
+			$this->where = $args[0];
+			$this->where_values = &$values;
+		}
+	}
+
+	private function build_delete()
+	{
+		$sql = "DELETE FROM $this->table";
+
+		if ($this->where)
+			$sql .= " WHERE $this->where";
+
+		return $sql;
+	}
+
+	private function build_insert()
+	{
+		require_once 'Expressions.php';
+		$keys = join(',',$this->quoted_key_names());
+
+		if ($this->sequence)
+		{
+			$sql =
+				"INSERT INTO $this->table($keys," . $this->connection->quote_name($this->sequence[0]) .
+				") VALUES(?," . $this->connection->next_sequence_value($this->sequence[1]) . ")";
+		}
+		else
+			$sql = "INSERT INTO $this->table($keys) VALUES(?)";
+
+		$e = new Expressions($this->connection,$sql,array_values($this->data));
+		return $e->to_s();
+	}
+
+	private function build_select()
+	{
+		$sql = "SELECT $this->select FROM $this->table";
+
+		if ($this->joins)
+			$sql .= ' ' . $this->joins;
+
+		if ($this->where)
+			$sql .= " WHERE $this->where";
+
+		if ($this->group)
+			$sql .= " GROUP BY $this->group";
+
+		if ($this->having)
+			$sql .= " HAVING $this->having";
+
+		if ($this->order)
+			$sql .= " ORDER BY $this->order";
+
+		if ($this->limit || $this->offset)
+			$sql = $this->connection->limit($sql,$this->offset,$this->limit);
+
+		return $sql;
+	}
+
+	private function build_update()
+	{
+		$fields = $this->quoted_key_names();
+		$sql = "UPDATE $this->table SET " . join('=?, ',$fields) . '=?';
+
+		if ($this->where)
+			$sql .= " WHERE $this->where";
+
+		return $sql;
+	}
+
+	private function quoted_key_names()
+	{
+		$keys = array();
+
+		foreach ($this->data as $key => $value)
+			$keys[] = $this->connection->quote_name($key);
+
+		return $keys;
+	}
+}
+?>

data/www/lib/php/plugins/php-activerecord/lib/Serialization.php

@@ -0,0 +1,302 @@
+<?php
+/**
+ * @package ActiveRecord
+ */
+namespace ActiveRecord;
+use XmlWriter;
+
+/**
+ * Base class for Model serializers.
+ *
+ * All serializers support the following options:
+ *
+ * <ul>
+ * <li><b>only:</b> a string or array of attributes to be included.</li>
+ * <li><b>exclude:</b> a string or array of attributes to be excluded.</li>
+ * <li><b>methods:</b> a string or array of methods to invoke. The method's name will be used as a key for the final attributes array
+ * along with the method's returned value</li>
+ * <li><b>include:</b> a string or array of associated models to include in the final serialized product.</li>
+ * <li><b>skip_instruct:</b> set to true to skip the <?xml ...?> declaration.</li>
+ * </ul>
+ *
+ * Example usage:
+ *
+ * <code>
+ * # include the attributes id and name
+ * # run $model->encoded_description() and include its return value
+ * # include the comments association
+ * # include posts association with its own options (nested)
+ * $model->to_json(array(
+ *   'only' => array('id','name', 'encoded_description'),
+ *   'methods' => array('encoded_description'),
+ *   'include' => array('comments', 'posts' => array('only' => 'id'))
+ * ));
+ *
+ * # exclude the password field from being included
+ * $model->to_xml(array('exclude' => 'password')));
+ * </code>
+ *
+ * @package ActiveRecord
+ * @link http://www.phpactiverecord.org/guides/utilities#topic-serialization
+ */
+abstract class Serialization
+{
+	protected $model;
+	protected $options;
+	protected $attributes;
+
+	/**
+	 * Set this to true if the serializer needs to create a nested array keyed
+	 * on the name of the included classes such as for xml serialization.
+	 *
+	 * Setting this to true will produce the following attributes array when
+	 * the include option was used:
+	 *
+	 * <code>
+	 * $user = array('id' => 1, 'name' => 'Tito',
+	 *   'permissions' => array(
+	 *     'permission' => array(
+	 *       array('id' => 100, 'name' => 'admin'),
+	 *       array('id' => 101, 'name' => 'normal')
+	 *     )
+	 *   )
+	 * );
+	 * </code>
+	 *
+	 * Setting to false will produce this:
+	 *
+	 * <code>
+	 * $user = array('id' => 1, 'name' => 'Tito',
+	 *   'permissions' => array(
+	 *     array('id' => 100, 'name' => 'admin'),
+	 *     array('id' => 101, 'name' => 'normal')
+	 *   )
+	 * );
+	 * </code>
+	 *
+	 * @var boolean
+	 */
+	protected $includes_with_class_name_element = false;
+
+	/**
+	 * Constructs a {@link Serialization} object.
+	 *
+	 * @param Model $model The model to serialize
+	 * @param array &$options Options for serialization
+	 * @return Serialization
+	 */
+	public function __construct(Model $model, &$options)
+	{
+		$this->model = $model;
+		$this->options = $options;
+		$this->attributes = $model->attributes();
+		$this->parse_options();
+	}
+
+	private function parse_options()
+	{
+		$this->check_only();
+		$this->check_except();
+		$this->check_methods();
+		$this->check_include();
+	}
+
+	private function check_only()
+	{
+		if (isset($this->options['only']))
+		{
+			$this->options_to_a('only');
+
+			$exclude = array_diff(array_keys($this->attributes),$this->options['only']);
+			$this->attributes = array_diff_key($this->attributes,array_flip($exclude));
+		}
+	}
+
+	private function check_except()
+	{
+		if (isset($this->options['except']) && !isset($this->options['only']))
+		{
+			$this->options_to_a('except');
+			$this->attributes = array_diff_key($this->attributes,array_flip($this->options['except']));
+		}
+	}
+
+	private function check_methods()
+	{
+		if (isset($this->options['methods']))
+		{
+			$this->options_to_a('methods');
+
+			foreach ($this->options['methods'] as $method)
+			{
+				if (method_exists($this->model, $method))
+					$this->attributes[$method] = $this->model->$method();
+			}
+		}
+	}
+
+	private function check_include()
+	{
+		if (isset($this->options['include']))
+		{
+			$this->options_to_a('include');
+
+			$serializer_class = get_class($this);
+
+			foreach ($this->options['include'] as $association => $options)
+			{
+				if (!is_array($options))
+				{
+					$association = $options;
+					$options = array();
+				}
+
+				try {
+					$assoc = $this->model->$association;
+
+					if (!is_array($assoc))
+					{
+						$serialized = new $serializer_class($assoc, $options);
+						$this->attributes[$association] = $serialized->to_a();;
+					}
+					else
+					{
+						$includes = array();
+
+						foreach ($assoc as $a)
+						{
+							$serialized = new $serializer_class($a, $options);
+
+							if ($this->includes_with_class_name_element)
+								$includes[strtolower(get_class($a))][] = $serialized->to_a();
+							else
+								$includes[] = $serialized->to_a();
+						}
+
+						$this->attributes[$association] = $includes;
+					}
+
+				} catch (UndefinedPropertyException $e) {
+					;//move along
+				}
+			}
+		}
+	}
+
+	final protected function options_to_a($key)
+	{
+		if (!is_array($this->options[$key]))
+			$this->options[$key] = array($this->options[$key]);
+	}
+
+	/**
+	 * Returns the attributes array.
+	 * @return array
+	 */
+	final public function to_a()
+	{
+		$date_format = Config::instance()->get_date_format();
+
+		foreach ($this->attributes as &$value)
+		{
+			if ($value instanceof \DateTime)
+				$value = $value->format($date_format);
+		}
+		return $this->attributes;
+	}
+
+	/**
+	 * Returns the serialized object as a string.
+	 * @see to_s
+	 * @return string
+	 */
+	final public function __toString()
+	{
+		return $this->to_s();
+	}
+
+	/**
+	 * Performs the serialization.
+	 * @return string
+	 */
+	abstract public function to_s();
+};
+
+/**
+ * JSON serializer.
+ *
+ * @package ActiveRecord
+ */
+class JsonSerializer extends Serialization
+{
+	public static $include_root = false;
+
+	public function to_s()
+	{
+		return json_encode(self::$include_root ? array(strtolower(get_class($this->model)) => $this->to_a()) : $this->to_a());
+	}
+}
+
+/**
+ * XML serializer.
+ *
+ * @package ActiveRecord
+ */
+class XmlSerializer extends Serialization
+{
+	private $writer;
+
+	public function __construct(Model $model, &$options)
+	{
+		$this->includes_with_class_name_element = true;
+		parent::__construct($model,$options);
+	}
+
+	public function to_s()
+	{
+		return $this->xml_encode();
+	}
+
+	private function xml_encode()
+	{
+		$this->writer = new XmlWriter();
+		$this->writer->openMemory();
+		$this->writer->startDocument('1.0', 'UTF-8');
+		$this->writer->startElement(strtolower(denamespace(($this->model))));
+		$this->write($this->to_a());
+		$this->writer->endElement();
+		$this->writer->endDocument();
+		$xml = $this->writer->outputMemory(true);
+
+		if (@$this->options['skip_instruct'] == true)
+			$xml = preg_replace('/<\?xml version.*?\?>/','',$xml);
+
+		return $xml;
+	}
+
+	private function write($data, $tag=null)
+	{
+		foreach ($data as $attr => $value)
+		{
+			if ($tag != null)
+				$attr = $tag;
+
+			if (is_array($value) || is_object($value))
+			{
+				if (!is_int(key($value)))
+				{
+					$this->writer->startElement($attr);
+					$this->write($value);
+					$this->writer->endElement();
+				}
+				else
+					$this->write($value, $attr);
+
+				continue;
+			}
+
+			$this->writer->writeElement($attr, $value);
+		}
+	}
+}
+?>