ci-bonfire / Sprint

myth/CIModules/auth/models/Login_model.php

Indentation +352 added lines, -352 removed lines

@@ -41,357 +41,357 @@
  */
 class Login_model extends \Myth\Models\CIDbModel {
 
-    protected $table_name = 'auth_logins';
-
-    protected $set_created = false;
-    protected $set_modified = false;
-
-    //--------------------------------------------------------------------
-
-    //--------------------------------------------------------------------
-    // Login Attempts
-    //--------------------------------------------------------------------
-
-    /**
-     * Records a login attempt. This is used to implement
-     * throttling of application, ip address and user login attempts.
-     *
-     * @param $ip_address
-     * @param $user_id
-     * @return void
-     */
-    public function recordLoginAttempt($ip_address, $user_id = null)
-    {
-        $datetime = date('Y-m-d H:i:s');
-
-        // log attempt for app
-        $data = [
-            'type' => 'app',
-            'datetime' => $datetime
-        ];
-
-        $this->db->insert('auth_login_attempts', $data);
-
-        // log attempt for ip address
-        if (! empty($ip_address))
-        {
-            $data = [
-                'type' => 'ip',
-                'ip_address' => $ip_address,
-                'datetime' => $datetime
-            ];
-
-            $this->db->insert('auth_login_attempts', $data);
-        }
-
-        // log attempt for user
-        if ($user_id)
-        {
-            $data = [
-                'type' => 'user',
-                'user_id' => $user_id,
-                'datetime' => $datetime
-            ];
-
-            $this->db->insert('auth_login_attempts', $data);
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Purges all login attempt records from the database.
-     *
-     * @param $ip_address
-     * @param $user_id
-     * @return mixed
-     */
-    public function purgeLoginAttempts($ip_address, $user_id)
-    {
-        if ($ip_address)
-        {
-            $this->db->where('ip_address', $ip_address);
-        }
-
-        if ($user_id)
-        {
-            $this->db->or_where('user_id', $user_id);
-        }
-
-        return $this->db->delete('auth_login_attempts');
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Checks to see if how many login attempts have been attempted in the
-     * last 60 seconds. If over 100, it is considered to be under a
-     * brute force attempt.
-     *
-     * @param $ip_address
-     * @param $user_id
-     * @return bool
-     */
-    public function isBruteForced($ip_address, $user_id)
-    {
-        $start_time = date('Y-m-d H:i:s', time() - 60);
-
-        $attempts_ip = $this->db->where('type', 'ip')
-                                ->where('ip_address', $ip_address)
-                                ->where('datetime >=', $start_time)
-                                ->count_all_results('auth_login_attempts');
-
-        if (! $user_id)
-        {
-            return $attempts_ip > 100;
-        }
-
-        $attempts_user = $this->db->where('type', 'user')
-                                  ->where('user_id', $user_id)
-                                  ->where('datetime >=', $start_time)
-                                  ->count_all_results('auth_login_attempts');
-
-        if ($attempts_user > $attempts_ip) 
-        {
-            return $attempts_user > 100;
-        }
-        else
-        {
-            return $attempts_ip > 100;
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Attempts to determine if the system is under a distributed
-     * brute force attack.
-     *
-     * To determine if we are in under a brute force attack, we first
-     * find the average number of bad logins per day that never converted to
-     * successful logins over the last 3 months. Then we compare
-     * that to the the average number of logins in the past 24 hours.
-     *
-     * If the number of attempts in the last 24 hours is more than X (see config)
-     * times the average, then institute additional throttling.
-     *
-     * @return int The time to add to any throttling.
-     */
-    public function distributedBruteForceTime()
-    {
-        if (! $time = $this->cache->get('dbrutetime'))
-        {
-            $time = 0;
-
-            // Compute our daily average over the last 3 months.
-            $avg_start_time = date('Y-m-d 00:00:00', strtotime('-3 months'));
-
-            $query = $this->db->query("SELECT COUNT(*) / COUNT(DISTINCT DATE(`datetime`)) as num_rows FROM `auth_login_attempts` WHERE `type` = 'app' AND `datetime` >= ?", $avg_start_time);
-
-            if (! $query->num_rows())
-            {
-                $average = 0;
-            }
-            else
-            {
-                $average = $query->row()->num_rows;
-            }
-
-            // Get the total in the last 24 hours
-            $today_start_time = date('Y-m-d H:i:s', strtotime('-24 hours'));
-
-            $attempts = $this->db->where('type', 'app')
-                                 ->where('datetime >=', $today_start_time)
-                                 ->count_all_results('auth_login_attempts');
-
-            if ($attempts > (config_item('auth.dbrute_multiplier') * $average))
-            {
-                $time = config_item('auth.distributed_brute_add_time');
-            }
-
-            // Cache it for 3 hours.
-            $this->cache->save('dbrutetime', $time, 60*60*3);
-        }
-
-        return $time;
-    }
-
-    //--------------------------------------------------------------------
-
-    //--------------------------------------------------------------------
-    // Logins
-    //--------------------------------------------------------------------
-
-    /**
-     * Records a successful login. This stores in a table so that a
-     * history can be pulled up later if needed for security analyses.
-     *
-     * @param $user
-     */
-    public function recordLogin($user)
-    {
-        $data = [
-            'user_id'    => (int)$user['id'],
-            'datetime'   => date('Y-m-d H:i:s'),
-            'ip_address' => $this->input->ip_address()
-        ];
-
-        return $this->db->insert('auth_logins', $data);
-    }
-
-    //--------------------------------------------------------------------
-
-    //--------------------------------------------------------------------
-    // Tokens
-    //--------------------------------------------------------------------
-
-    /**
-     * Generates a new token for the rememberme cookie.
-     *
-     * The token is based on the user's email address (since everyone will have one)
-     * with the '@' turned to a '.', followed by a pipe (|) and a random 128-character
-     * string with letters and numbers.
-     *
-     * @param $user
-     * @return mixed
-     */
-    public function generateRememberToken($user)
-    {
-        $this->load->helper('string');
-
-        return str_replace('@', '.', $user['email']) .'|' . random_string('alnum', 128);
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Hashes the token for the Remember Me Functionality.
-     *
-     * @param $token
-     * @return string
-     */
-    public function hashRememberToken($token)
-    {
-        return sha1(config_item('auth.salt') . $token);
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Deletes a single token that matches the email/token combo.
-     *
-     * @param $email
-     * @param $token
-     * @return mixed
-     */
-    public function deleteRememberToken($email, $token)
-    {
-        $where = [
-            'email' => $email,
-            'hash'  => $this->hashRememberToken($token)
-        ];
-
-        $this->db->delete('auth_tokens', $where);
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Removes all persistent login tokens (RememberMe) for a single user
-     * across all devices they may have logged in with.
-     *
-     * @param $email
-     * @return mixed
-     */
-    public function purgeRememberTokens($email)
-    {
-        return $this->db->delete('auth_tokens', ['email' => $email]);
-    }
-
-    //--------------------------------------------------------------------
-
-
-    /**
-     * Purges the 'auth_tokens' table of any records that are too old
-     * to be of any use anymore. This equates to 1 week older than
-     * the remember_length set in the config file.
-     */
-    public function purgeOldRememberTokens()
-    {
-        if (! config_item('auth.allow_remembering'))
-        {
-            return;
-        }
-
-        $date = time() - config_item('auth.remember_length') - 604800; // 1 week
-        $date = date('Y-m-d 00:00:00', $date);
-
-        $this->db->where('created <=', $date)
-                 ->delete('auth_tokens');
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Gets the timestamp of the last attempted login for this user.
-     *
-     * @param $ip_address
-     * @param $user_id
-     * @return int|null
-     */
-    public function lastLoginAttemptTime($ip_address, $user_id)
-    {
-        $query = $this->db->where('type', 'ip')
-                          ->where('ip_address', $ip_address)
-                          ->order_by('datetime', 'desc')
-                          ->limit(1)
-                          ->get('auth_login_attempts');
-
-        $last_ip = ! $query->num_rows() ? 0 : strtotime($query->row()->datetime);
-
-        if (! $user_id)
-        {
-            return $last_ip;
-        }
-
-        $query = $this->db->where('type', 'user')
-                          ->where('user_id', $user_id)
-                          ->order_by('datetime', 'desc')
-                          ->limit(1)
-                          ->get('auth_login_attempts');
-
-        $last_user = ! $query->num_rows() ? 0 : strtotime($query->row()->datetime);
-
-        return ($last_user > $last_ip) ? $last_user : $last_ip;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Returns the number of failed login attempts for a given type.
-     *
-     * @param $ip_address
-     * @param $user_id
-     * @return int
-     */
-    public function countLoginAttempts($ip_address, $user_id)
-    {
-        $count_ip = $this->db->where('type', 'ip')
-                             ->where('ip_address', $ip_address)
-                             ->count_all_results('auth_login_attempts');
-
-        if (! $user_id)
-        {
-            return $count_ip;
-        }
-
-        $count_user = $this->db->where('type', 'user')
-                               ->where('user_id', $user_id)
-                               ->count_all_results('auth_login_attempts');
-
-        return ($count_user > $count_ip) ? $count_user : $count_ip;
-    }
-
-    //--------------------------------------------------------------------
+	protected $table_name = 'auth_logins';
+
+	protected $set_created = false;
+	protected $set_modified = false;
+
+	//--------------------------------------------------------------------
+
+	//--------------------------------------------------------------------
+	// Login Attempts
+	//--------------------------------------------------------------------
+
+	/**
+	 * Records a login attempt. This is used to implement
+	 * throttling of application, ip address and user login attempts.
+	 *
+	 * @param $ip_address
+	 * @param $user_id
+	 * @return void
+	 */
+	public function recordLoginAttempt($ip_address, $user_id = null)
+	{
+		$datetime = date('Y-m-d H:i:s');
+
+		// log attempt for app
+		$data = [
+			'type' => 'app',
+			'datetime' => $datetime
+		];
+
+		$this->db->insert('auth_login_attempts', $data);
+
+		// log attempt for ip address
+		if (! empty($ip_address))
+		{
+			$data = [
+				'type' => 'ip',
+				'ip_address' => $ip_address,
+				'datetime' => $datetime
+			];
+
+			$this->db->insert('auth_login_attempts', $data);
+		}
+
+		// log attempt for user
+		if ($user_id)
+		{
+			$data = [
+				'type' => 'user',
+				'user_id' => $user_id,
+				'datetime' => $datetime
+			];
+
+			$this->db->insert('auth_login_attempts', $data);
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Purges all login attempt records from the database.
+	 *
+	 * @param $ip_address
+	 * @param $user_id
+	 * @return mixed
+	 */
+	public function purgeLoginAttempts($ip_address, $user_id)
+	{
+		if ($ip_address)
+		{
+			$this->db->where('ip_address', $ip_address);
+		}
+
+		if ($user_id)
+		{
+			$this->db->or_where('user_id', $user_id);
+		}
+
+		return $this->db->delete('auth_login_attempts');
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Checks to see if how many login attempts have been attempted in the
+	 * last 60 seconds. If over 100, it is considered to be under a
+	 * brute force attempt.
+	 *
+	 * @param $ip_address
+	 * @param $user_id
+	 * @return bool
+	 */
+	public function isBruteForced($ip_address, $user_id)
+	{
+		$start_time = date('Y-m-d H:i:s', time() - 60);
+
+		$attempts_ip = $this->db->where('type', 'ip')
+								->where('ip_address', $ip_address)
+								->where('datetime >=', $start_time)
+								->count_all_results('auth_login_attempts');
+
+		if (! $user_id)
+		{
+			return $attempts_ip > 100;
+		}
+
+		$attempts_user = $this->db->where('type', 'user')
+								  ->where('user_id', $user_id)
+								  ->where('datetime >=', $start_time)
+								  ->count_all_results('auth_login_attempts');
+
+		if ($attempts_user > $attempts_ip) 
+		{
+			return $attempts_user > 100;
+		}
+		else
+		{
+			return $attempts_ip > 100;
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Attempts to determine if the system is under a distributed
+	 * brute force attack.
+	 *
+	 * To determine if we are in under a brute force attack, we first
+	 * find the average number of bad logins per day that never converted to
+	 * successful logins over the last 3 months. Then we compare
+	 * that to the the average number of logins in the past 24 hours.
+	 *
+	 * If the number of attempts in the last 24 hours is more than X (see config)
+	 * times the average, then institute additional throttling.
+	 *
+	 * @return int The time to add to any throttling.
+	 */
+	public function distributedBruteForceTime()
+	{
+		if (! $time = $this->cache->get('dbrutetime'))
+		{
+			$time = 0;
+
+			// Compute our daily average over the last 3 months.
+			$avg_start_time = date('Y-m-d 00:00:00', strtotime('-3 months'));
+
+			$query = $this->db->query("SELECT COUNT(*) / COUNT(DISTINCT DATE(`datetime`)) as num_rows FROM `auth_login_attempts` WHERE `type` = 'app' AND `datetime` >= ?", $avg_start_time);
+
+			if (! $query->num_rows())
+			{
+				$average = 0;
+			}
+			else
+			{
+				$average = $query->row()->num_rows;
+			}
+
+			// Get the total in the last 24 hours
+			$today_start_time = date('Y-m-d H:i:s', strtotime('-24 hours'));
+
+			$attempts = $this->db->where('type', 'app')
+								 ->where('datetime >=', $today_start_time)
+								 ->count_all_results('auth_login_attempts');
+
+			if ($attempts > (config_item('auth.dbrute_multiplier') * $average))
+			{
+				$time = config_item('auth.distributed_brute_add_time');
+			}
+
+			// Cache it for 3 hours.
+			$this->cache->save('dbrutetime', $time, 60*60*3);
+		}
+
+		return $time;
+	}
+
+	//--------------------------------------------------------------------
+
+	//--------------------------------------------------------------------
+	// Logins
+	//--------------------------------------------------------------------
+
+	/**
+	 * Records a successful login. This stores in a table so that a
+	 * history can be pulled up later if needed for security analyses.
+	 *
+	 * @param $user
+	 */
+	public function recordLogin($user)
+	{
+		$data = [
+			'user_id'    => (int)$user['id'],
+			'datetime'   => date('Y-m-d H:i:s'),
+			'ip_address' => $this->input->ip_address()
+		];
+
+		return $this->db->insert('auth_logins', $data);
+	}
+
+	//--------------------------------------------------------------------
+
+	//--------------------------------------------------------------------
+	// Tokens
+	//--------------------------------------------------------------------
+
+	/**
+	 * Generates a new token for the rememberme cookie.
+	 *
+	 * The token is based on the user's email address (since everyone will have one)
+	 * with the '@' turned to a '.', followed by a pipe (|) and a random 128-character
+	 * string with letters and numbers.
+	 *
+	 * @param $user
+	 * @return mixed
+	 */
+	public function generateRememberToken($user)
+	{
+		$this->load->helper('string');
+
+		return str_replace('@', '.', $user['email']) .'|' . random_string('alnum', 128);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Hashes the token for the Remember Me Functionality.
+	 *
+	 * @param $token
+	 * @return string
+	 */
+	public function hashRememberToken($token)
+	{
+		return sha1(config_item('auth.salt') . $token);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Deletes a single token that matches the email/token combo.
+	 *
+	 * @param $email
+	 * @param $token
+	 * @return mixed
+	 */
+	public function deleteRememberToken($email, $token)
+	{
+		$where = [
+			'email' => $email,
+			'hash'  => $this->hashRememberToken($token)
+		];
+
+		$this->db->delete('auth_tokens', $where);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Removes all persistent login tokens (RememberMe) for a single user
+	 * across all devices they may have logged in with.
+	 *
+	 * @param $email
+	 * @return mixed
+	 */
+	public function purgeRememberTokens($email)
+	{
+		return $this->db->delete('auth_tokens', ['email' => $email]);
+	}
+
+	//--------------------------------------------------------------------
+
+
+	/**
+	 * Purges the 'auth_tokens' table of any records that are too old
+	 * to be of any use anymore. This equates to 1 week older than
+	 * the remember_length set in the config file.
+	 */
+	public function purgeOldRememberTokens()
+	{
+		if (! config_item('auth.allow_remembering'))
+		{
+			return;
+		}
+
+		$date = time() - config_item('auth.remember_length') - 604800; // 1 week
+		$date = date('Y-m-d 00:00:00', $date);
+
+		$this->db->where('created <=', $date)
+				 ->delete('auth_tokens');
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Gets the timestamp of the last attempted login for this user.
+	 *
+	 * @param $ip_address
+	 * @param $user_id
+	 * @return int|null
+	 */
+	public function lastLoginAttemptTime($ip_address, $user_id)
+	{
+		$query = $this->db->where('type', 'ip')
+						  ->where('ip_address', $ip_address)
+						  ->order_by('datetime', 'desc')
+						  ->limit(1)
+						  ->get('auth_login_attempts');
+
+		$last_ip = ! $query->num_rows() ? 0 : strtotime($query->row()->datetime);
+
+		if (! $user_id)
+		{
+			return $last_ip;
+		}
+
+		$query = $this->db->where('type', 'user')
+						  ->where('user_id', $user_id)
+						  ->order_by('datetime', 'desc')
+						  ->limit(1)
+						  ->get('auth_login_attempts');
+
+		$last_user = ! $query->num_rows() ? 0 : strtotime($query->row()->datetime);
+
+		return ($last_user > $last_ip) ? $last_user : $last_ip;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Returns the number of failed login attempts for a given type.
+	 *
+	 * @param $ip_address
+	 * @param $user_id
+	 * @return int
+	 */
+	public function countLoginAttempts($ip_address, $user_id)
+	{
+		$count_ip = $this->db->where('type', 'ip')
+							 ->where('ip_address', $ip_address)
+							 ->count_all_results('auth_login_attempts');
+
+		if (! $user_id)
+		{
+			return $count_ip;
+		}
+
+		$count_user = $this->db->where('type', 'user')
+							   ->where('user_id', $user_id)
+							   ->count_all_results('auth_login_attempts');
+
+		return ($count_user > $count_ip) ? $count_user : $count_ip;
+	}
+
+	//--------------------------------------------------------------------
 
 }

myth/Auth/AuthenticateInterface.php

Indentation +192 added lines, -192 removed lines

@@ -42,197 +42,197 @@
  */
 interface AuthenticateInterface {
 
-    /**
-     * Attempt to log a user into the system.
-     *
-     * $credentials is an array of key/value pairs needed to log the user in.
-     * This is often email/password, or username/password.
-     *
-     * @param $credentials
-     * @param bool $remember
-     */
-    public function login($credentials, $remember=false);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Validates user login information without logging them in.
-     *
-     * $credentials is an array of key/value pairs needed to log the user in.
-     * This is often email/password, or username/password.
-     *
-     * @param $credentials
-     * @param bool $return_user
-     * @return mixed
-     */
-    public function validate($credentials, $return_user=false);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Logs a user out and removes all session information.
-     *
-     * @return mixed
-     */
-    public function logout();
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Checks whether a user is logged in or not.
-     *
-     * @return bool
-     */
-    public function isLoggedIn();
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Attempts to log a user in based on the "remember me" cookie.
-     *
-     * @return bool
-     */
-    public function viaRemember();
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Registers a new user and handles activation method.
-     *
-     * @param $user_data
-     * @return bool
-     */
-    public function registerUser($user_data);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Used to verify the user values and activate a user so they can
-     * visit the site.
-     *
-     * @param $data
-     * @return bool
-     */
-    public function activateUser($data);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Used to allow manual activation of a user with a known ID.
-     *
-     * @param $id
-     * @return bool
-     */
-    public function activateUserById($id);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Grabs the current user object. Returns NULL if nothing found.
-     *
-     * @return array|null
-     */
-    public function user();
-
-    //--------------------------------------------------------------------
-
-    /**
-     * A convenience method to grab the current user's ID.
-     *
-     * @return int|null
-     */
-    public function id();
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Tells the system to start throttling a user. This may vary by implementation,
-     * but will often add additional time before another login is allowed.
-     *
-     * @param $email
-     * @return mixed
-     */
-    public function isThrottled($email);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Sends a password reminder email to the user associated with
-     * the passed in $email.
-     *
-     * @param $email
-     * @return mixed
-     */
-    public function remindUser($email);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Validates the credentials provided and, if valid, resets the password.
-     *
-     * @param $credentials
-     * @param $password
-     * @param $passConfirm
-     * @return mixed
-     */
-    public function resetPassword($credentials, $password, $passConfirm);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Provides a way for implementations to allow new statuses to be set
-     * on the user. The details will vary based upon implementation, but
-     * will often allow for banning or suspending users.
-     *
-     * @param $newStatus
-     * @param null $message
-     * @return mixed
-     */
-    public function changeStatus($newStatus, $message=null);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Allows the consuming application to pass in a reference to the
-     * model that should be used.
-     *
-     * The model MUST extend Myth\Models\CIDbModel.
-     *
-     * @param $model
-     * @return mixed
-     */
-    public function useModel($model);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Returns the current error string.
-     *
-     * @return mixed
-     */
-    public function error();
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Purges all login attempt records from the database.
-     *
-     * @param null $ip_address
-     * @param null $user_id
-     */
-    public function purgeLoginAttempts($ip_address = null, $user_id = null);
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Purges all remember tokens for a single user. Effectively logs
-     * a user out of all devices. Intended to allow users to log themselves
-     * out of all devices as a security measure.
-     *
-     * @param $email
-     */
-    public function purgeRememberTokens($email);
-
-    //--------------------------------------------------------------------
+	/**
+	 * Attempt to log a user into the system.
+	 *
+	 * $credentials is an array of key/value pairs needed to log the user in.
+	 * This is often email/password, or username/password.
+	 *
+	 * @param $credentials
+	 * @param bool $remember
+	 */
+	public function login($credentials, $remember=false);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Validates user login information without logging them in.
+	 *
+	 * $credentials is an array of key/value pairs needed to log the user in.
+	 * This is often email/password, or username/password.
+	 *
+	 * @param $credentials
+	 * @param bool $return_user
+	 * @return mixed
+	 */
+	public function validate($credentials, $return_user=false);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Logs a user out and removes all session information.
+	 *
+	 * @return mixed
+	 */
+	public function logout();
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Checks whether a user is logged in or not.
+	 *
+	 * @return bool
+	 */
+	public function isLoggedIn();
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Attempts to log a user in based on the "remember me" cookie.
+	 *
+	 * @return bool
+	 */
+	public function viaRemember();
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Registers a new user and handles activation method.
+	 *
+	 * @param $user_data
+	 * @return bool
+	 */
+	public function registerUser($user_data);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Used to verify the user values and activate a user so they can
+	 * visit the site.
+	 *
+	 * @param $data
+	 * @return bool
+	 */
+	public function activateUser($data);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Used to allow manual activation of a user with a known ID.
+	 *
+	 * @param $id
+	 * @return bool
+	 */
+	public function activateUserById($id);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Grabs the current user object. Returns NULL if nothing found.
+	 *
+	 * @return array|null
+	 */
+	public function user();
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * A convenience method to grab the current user's ID.
+	 *
+	 * @return int|null
+	 */
+	public function id();
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Tells the system to start throttling a user. This may vary by implementation,
+	 * but will often add additional time before another login is allowed.
+	 *
+	 * @param $email
+	 * @return mixed
+	 */
+	public function isThrottled($email);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Sends a password reminder email to the user associated with
+	 * the passed in $email.
+	 *
+	 * @param $email
+	 * @return mixed
+	 */
+	public function remindUser($email);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Validates the credentials provided and, if valid, resets the password.
+	 *
+	 * @param $credentials
+	 * @param $password
+	 * @param $passConfirm
+	 * @return mixed
+	 */
+	public function resetPassword($credentials, $password, $passConfirm);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Provides a way for implementations to allow new statuses to be set
+	 * on the user. The details will vary based upon implementation, but
+	 * will often allow for banning or suspending users.
+	 *
+	 * @param $newStatus
+	 * @param null $message
+	 * @return mixed
+	 */
+	public function changeStatus($newStatus, $message=null);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Allows the consuming application to pass in a reference to the
+	 * model that should be used.
+	 *
+	 * The model MUST extend Myth\Models\CIDbModel.
+	 *
+	 * @param $model
+	 * @return mixed
+	 */
+	public function useModel($model);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Returns the current error string.
+	 *
+	 * @return mixed
+	 */
+	public function error();
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Purges all login attempt records from the database.
+	 *
+	 * @param null $ip_address
+	 * @param null $user_id
+	 */
+	public function purgeLoginAttempts($ip_address = null, $user_id = null);
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Purges all remember tokens for a single user. Effectively logs
+	 * a user out of all devices. Intended to allow users to log themselves
+	 * out of all devices as a security measure.
+	 *
+	 * @param $email
+	 */
+	public function purgeRememberTokens($email);
+
+	//--------------------------------------------------------------------
 
 }

myth/Mail/Mail.php

Indentation +136 added lines, -136 removed lines

@@ -32,141 +32,141 @@
 
 class Mail {
 
-    /**
-     * Sends an email, using an existing Mailer, which can
-     * be found in application/mailers/. The mailer is the one responsible
-     * for determining whether the email will be sent immediately or queued
-     * to be sent later.
-     *
-     * The $mailer_name must include both the mailer name as well as the
-     * task, separated by a single colon:
-     *      'UserMailer:newUser'
-     *
-     * @param $mailer_name
-     * @param array $params
-     * @param array $options
-     * @return mixed
-     */
-    public static function deliver($mailer_name, $params=[], $options=[])
-    {
-        // Protect users from themselves here.
-        str_replace('::', ':', $mailer_name);
-
-        // Try to load our mailer class.
-        list($class, $method) = explode(':', $mailer_name);
-
-        if (! is_file(APPPATH .'mailers/'. $class .'.php'))
-        {
-            throw new \RuntimeException( sprintf( lang('mail.cant_find_mailer'), $class) );
-        }
-
-        require_once APPPATH .'mailers/'. $class .'.php';
-
-        if (! class_exists($class, false))
-        {
-            throw new \RuntimeException( sprintf( lang('errors.cant_instantiate'), $class) );
-        }
-
-        $mailer = new $class( $options );
-
-        if (! method_exists($mailer, $method))
-        {
-            throw new \BadMethodCallException( sprintf( lang('mail.invalid_mailer_method'), $class, $method) );
-        }
-
-        // try to deliver the mail, but don't send back the contents
-        // since we don't want to force the mailers to return anything.
-        if (call_user_func_array([$mailer, $method], $params) )
-        {
-            return true;
-        }
-
-        return false;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Adds an item to the email queue to be sent out next time.
-     *
-     * @param string $mailer_name
-     * @param array $params
-     * @param array $options
-     * @param \Myth\Mail\Queue $queue
-     *
-     * @return mixed
-     */
-    public static function queue($mailer_name, $params=[], $options=[], &$queue=null)
-    {
-        $data = [
-            'mailer'    => $mailer_name,
-            'params'    => serialize($params),
-            'options'   => serialize($options)
-        ];
-
-        if (empty($queue))
-        {
-            $queue = new \Myth\Mail\Queue();
-        }
-
-        return $queue->insert($data);
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Processes the Email queue sending out emails in chunks.
-     * Typically used in a cronjob to send out all queued emails.
-     *
-     * @param int $chunk_size   // How many emails to send per batch.
-     * @return string           // The output of the cronjob...
-     */
-    public static function process($chunk_size=50, &$db=null)
-    {
-        if (empty($db))
-        {
-            $db = new \Myth\Mail\Queue();
-        }
-
-        // Grab our batch of emails to process
-        $queue = $db->find_many_by('sent', 0);
-
-        if (! $queue)
-        {
-            // We didn't have an error, we simply
-            // didn't have anything to do.
-            return true;
-        }
-
-        $output = 'Started processing email Queue at '. date('Y-m-d H:i:s') .".\n\n";
-
-        foreach ($queue as $item)
-        {
-            try {
-                if (! Mail::deliver($item->mailer, unserialize($item->params), unserialize($item->options))) {
-                    $output .= '[FAILED] ';
-                } else {
-                    $data = [
-                        'sent'    => 1,
-                        'sent_on' => date('Y-m-d H:i:s')
-                    ];
-
-                    $db->update($item->id, $data);
-                }
-
-                $output .= "ID: {$item->id}, Mailer: {$item->mailer}. \n";
-            }
-            catch (\Exception $e)
-            {
-                $output .= "[EXCEPTION] ". $e->getMessage() ."\n";
-            }
-        }
-
-        $output .= "Done processing email Queue at ". date('H:i:s') .".\n";
-
-        return $output;
-    }
-
-    //--------------------------------------------------------------------
+	/**
+	 * Sends an email, using an existing Mailer, which can
+	 * be found in application/mailers/. The mailer is the one responsible
+	 * for determining whether the email will be sent immediately or queued
+	 * to be sent later.
+	 *
+	 * The $mailer_name must include both the mailer name as well as the
+	 * task, separated by a single colon:
+	 *      'UserMailer:newUser'
+	 *
+	 * @param $mailer_name
+	 * @param array $params
+	 * @param array $options
+	 * @return mixed
+	 */
+	public static function deliver($mailer_name, $params=[], $options=[])
+	{
+		// Protect users from themselves here.
+		str_replace('::', ':', $mailer_name);
+
+		// Try to load our mailer class.
+		list($class, $method) = explode(':', $mailer_name);
+
+		if (! is_file(APPPATH .'mailers/'. $class .'.php'))
+		{
+			throw new \RuntimeException( sprintf( lang('mail.cant_find_mailer'), $class) );
+		}
+
+		require_once APPPATH .'mailers/'. $class .'.php';
+
+		if (! class_exists($class, false))
+		{
+			throw new \RuntimeException( sprintf( lang('errors.cant_instantiate'), $class) );
+		}
+
+		$mailer = new $class( $options );
+
+		if (! method_exists($mailer, $method))
+		{
+			throw new \BadMethodCallException( sprintf( lang('mail.invalid_mailer_method'), $class, $method) );
+		}
+
+		// try to deliver the mail, but don't send back the contents
+		// since we don't want to force the mailers to return anything.
+		if (call_user_func_array([$mailer, $method], $params) )
+		{
+			return true;
+		}
+
+		return false;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Adds an item to the email queue to be sent out next time.
+	 *
+	 * @param string $mailer_name
+	 * @param array $params
+	 * @param array $options
+	 * @param \Myth\Mail\Queue $queue
+	 *
+	 * @return mixed
+	 */
+	public static function queue($mailer_name, $params=[], $options=[], &$queue=null)
+	{
+		$data = [
+			'mailer'    => $mailer_name,
+			'params'    => serialize($params),
+			'options'   => serialize($options)
+		];
+
+		if (empty($queue))
+		{
+			$queue = new \Myth\Mail\Queue();
+		}
+
+		return $queue->insert($data);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Processes the Email queue sending out emails in chunks.
+	 * Typically used in a cronjob to send out all queued emails.
+	 *
+	 * @param int $chunk_size   // How many emails to send per batch.
+	 * @return string           // The output of the cronjob...
+	 */
+	public static function process($chunk_size=50, &$db=null)
+	{
+		if (empty($db))
+		{
+			$db = new \Myth\Mail\Queue();
+		}
+
+		// Grab our batch of emails to process
+		$queue = $db->find_many_by('sent', 0);
+
+		if (! $queue)
+		{
+			// We didn't have an error, we simply
+			// didn't have anything to do.
+			return true;
+		}
+
+		$output = 'Started processing email Queue at '. date('Y-m-d H:i:s') .".\n\n";
+
+		foreach ($queue as $item)
+		{
+			try {
+				if (! Mail::deliver($item->mailer, unserialize($item->params), unserialize($item->options))) {
+					$output .= '[FAILED] ';
+				} else {
+					$data = [
+						'sent'    => 1,
+						'sent_on' => date('Y-m-d H:i:s')
+					];
+
+					$db->update($item->id, $data);
+				}
+
+				$output .= "ID: {$item->id}, Mailer: {$item->mailer}. \n";
+			}
+			catch (\Exception $e)
+			{
+				$output .= "[EXCEPTION] ". $e->getMessage() ."\n";
+			}
+		}
+
+		$output .= "Done processing email Queue at ". date('H:i:s') .".\n";
+
+		return $output;
+	}
+
+	//--------------------------------------------------------------------
 
 }

myth/Auth/LocalAuthentication.php

Indentation +908 added lines, -908 removed lines

@@ -52,915 +52,915 @@
  */
 class LocalAuthentication implements AuthenticateInterface {
 
-    protected $ci;
-
-    protected $user = null;
-
-    public $user_model = null;
-
-    public $error = null;
-
-    //--------------------------------------------------------------------
-
-    public function __construct( $ci=null )
-    {
-        if ($ci)
-        {
-            $this->ci= $ci;
-        }
-        else
-        {
-            $this->ci =& get_instance();
-        }
-
-        // Get our compatibility password file loaded up.
-        if (! function_exists('password_hash'))
-        {
-            require_once dirname(__FILE__) .'password.php';
-        }
-
-        if (empty($this->ci->session))
-        {
-            $this->ci->load->library('session');
-        }
-
-        $this->ci->config->load('auth');
-        $this->ci->load->model('auth/login_model');
-        $this->ci->load->language('auth/auth');
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Attempt to log a user into the system.
-     *
-     * $credentials is an array of key/value pairs needed to log the user in.
-     * This is often email/password, or username/password.
-     *
-     * @param array $credentials
-     * @param bool  $remember
-     * @return bool|mixed
-     */
-    public function login($credentials, $remember=false)
-    {
-        $user = $this->validate($credentials, true);
-
-        if (! $user)
-        {
-            $this->user = null;
-            return $user;
-        }       
-
-        $this->loginUser($user);
-
-        if ($remember)
-        {
-            $this->rememberUser($user);
-        }
-
-        Events::trigger('didLogin', [$user]);
-
-        return true;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Validates user login information without logging them in.
-     *
-     * $credentials is an array of key/value pairs needed to log the user in.
-     * This is often email/password, or username/password.
-     *
-     * @param $credentials
-     * @param bool $return_user
-     * @return mixed
-     */
-    public function validate($credentials, $return_user=false)
-    {
-        // Can't validate without a password.
-        if (empty($credentials['password']) || count($credentials) < 2)
-        {
-            return null;
-        }
-
-        $password = $credentials['password'];
-        unset($credentials['password']);
-
-        // We should only be allowed 1 single other credential to
-        // test against.
-        if (count($credentials) > 1)
-        {
-            $this->error = lang('auth.too_many_credentials');
-            return false;
-        }
-
-        // Ensure that the fields are allowed validation fields
-        if (! in_array(key($credentials), config_item('auth.valid_fields')) )
-        {
-            $this->error = lang('auth.invalid_credentials');
-            return false;
-        }
-
-        // We do not want to force case-sensitivity on things
-        // like username and email for usability sake.
-        if (! empty($credentials['email']))
-        {
-            $credentials['email'] = strtolower($credentials['email']);
-        }
-
-        // Can we find a user with those credentials?
-        $user = $this->user_model->as_array()
-                                 ->where($credentials)
-                                 ->first();
-
-        // If the user is throttled due to too many invalid logins
-        // or the system is under attack, kick them back.
-
-        // If throttling time is above zero, we can't allow
-        // logins now.
-        $time = (int)$this->isThrottled($user);
-        if ($time > 0)
-        {
-            $this->error = sprintf(lang('auth.throttled'), $time);
-            return false;
-        }
-
-        // Get ip address
-        $ip_address = $this->ci->input->ip_address();
-
-        if (! $user)
-        {
-            $this->error = lang('auth.invalid_user');
-            $this->ci->login_model->recordLoginAttempt($ip_address);
-            return false;
-        }
-
-        // Now, try matching the passwords.
-        $result =  password_verify($password, $user['password_hash']);
-
-        if (! $result)
-        {
-            $this->error = lang('auth.invalid_password');
-            $this->ci->login_model->recordLoginAttempt($ip_address, $user['id']);
-            return false;
-        }
-
-        // Check to see if the password needs to be rehashed.
-        // This would be due to the hash algorithm or hash
-        // cost changing since the last time that a user
-        // logged in.
-        if (password_needs_rehash($user['password_hash'], PASSWORD_DEFAULT, ['cost' => config_item('auth.hash_cost')] ))
-        {
-            $new_hash = Password::hashPassword($password);
-            $this->user_model->skip_validation()
-                             ->update($user['id'], ['password_hash' => $new_hash]);
-            unset($new_hash);
-        }
-
-        // Is the user active?
-        if (! $user['active'])
-        {
-            $this->error = lang('auth.inactive_account');
-            return false;
-        }
-
-        return $return_user ? $user : true;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Logs a user out and removes all session information.
-     *
-     * @return mixed
-     */
-    public function logout()
-    {
-        $this->ci->load->helper('cookie');
-
-        if (! Events::trigger('beforeLogout', [$this->user]))
-        {
-            return false;
-        }
-
-        // Destroy the session data - but ensure a session is still
-        // available for flash messages, etc.
-        if (isset($_SESSION))
-        {
-            foreach ( $_SESSION as $key => $value )
-            {
-                $_SESSION[ $key ] = NULL;
-                unset( $_SESSION[ $key ] );
-            }
-        }
-        // Also, regenerate the session ID for a touch of added safety.
-        $this->ci->session->sess_regenerate(true);
-
-        // Take care of any rememberme functionality.
-        if (config_item('auth.allow_remembering'))
-        {
-            $token = get_cookie('remember');
-
-            $this->invalidateRememberCookie($this->user['email'], $token);
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Checks whether a user is logged in or not.
-     *
-     * @return bool
-     */
-    public function isLoggedIn()
-    {
-        $id = $this->ci->session->userdata('logged_in');
-
-        if (! $id)
-        {
-            return false;
-        }
-
-        // If the user var hasn't been filled in, we need to fill it in,
-        // since this method will typically be used as the only method
-        // to determine whether a user is logged in or not.
-        if (! $this->user)
-        {
-            $this->user = $this->user_model->as_array()
-                                           ->find_by('id', (int)$id);
-
-            if (empty($this->user))
-            {
-                return false;
-            }
-        }
-
-        // If logged in, ensure cache control
-        // headers are in place
-        $this->setHeaders();
-
-        return true;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Attempts to log a user in based on the "remember me" cookie.
-     *
-     * @return bool
-     */
-    public function viaRemember()
-    {
-        if (! config_item('auth.allow_remembering'))
-        {
-            return false;
-        }
-
-        $this->ci->load->helper('cookie');
-
-        if (! $token = get_cookie('remember'))
-        {
-            return false;
-        }
-
-        // Attempt to match the token against our auth_tokens table.
-        $query = $this->ci->db->where('hash', $this->ci->login_model->hashRememberToken($token))
-                              ->get('auth_tokens');
-
-        if (! $query->num_rows())
-        {
-            return false;
-        }
-
-        // Grab the user
-        $email = $query->row()->email;
-
-        $user = $this->user_model->as_array()
-                                 ->find_by('email', $email);
-
-        $this->loginUser($user);
-
-        // We only want our remember me tokens to be valid
-        // for a single use.
-        $this->refreshRememberCookie($user, $token);
-
-        return true;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Registers a new user and handles activation method.
-     *
-     * @param $user_data
-     * @return bool
-     */
-    public function registerUser($user_data)
-    {
-        // Anything special needed for Activation?
-        $method = config_item('auth.activation_method');
-
-        $user_data['active'] = $method == 'auto' ? 1 : 0;
-
-        // If via email, we need to generate a hash
-        $this->ci->load->helper('string');
-        $token = random_string('alnum', 24);
-        $user_data['activate_hash'] = hash('sha1', config_item('auth.salt') . $token);
-
-        // Email should NOT be case sensitive.
-        if (! empty($user_data['email']))
-        {
-            $user_data['email'] = strtolower($user_data['email']);
-        }
-
-        // Save the user
-        if (! $id = $this->user_model->insert($user_data))
-        {
-            $this->error = $this->user_model->error();
-            return false;
-        }
-
-        $data = [
-            'user_id' => $id,
-            'email'   => $user_data['email'],
-            'token'   => $token,
-            'method'  => $method
-        ];
-
-        Events::trigger('didRegisterUser', [$data]);
-
-        return true;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Used to verify the user values and activate a user so they can
-     * visit the site.
-     *
-     * @param $data
-     * @return bool
-     */
-    public function activateUser($data)
-    {
-        $post = [
-            'email'         => $data['email'],
-            'activate_hash' => hash('sha1', config_item('auth.salt') . $data['code'])
-        ];
-
-        $user = $this->user_model->where($post)
-                                 ->first();
-
-        if (! $user) {
-            $this->error = $this->user_model->error() ? $this->user_model->error() : lang('auth.activate_no_user');
-
-            return false;
-        }
-
-        if (! $this->user_model->update($user->id, ['active' => 1, 'activate_hash' => null]))
-        {
-            $this->error = $this->user_model->error();
-            return false;
-        }
-
-        Events::trigger('didActivate', [(array)$user]);
-
-        return true;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Used to allow manual activation of a user with a known ID.
-     *
-     * @param $id
-     * @return bool
-     */
-    public function activateUserById($id)
-    {
-        if (! $this->user_model->update($id, ['active' => 1, 'activate_hash' => null]))
-        {
-            $this->error = $this->user_model->error();
-            return false;
-        }
-
-        Events::trigger('didActivate', [$this->user_model->as_array()->find($id)]);
-
-        return true;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Grabs the current user object. Returns NULL if nothing found.
-     *
-     * @return array|null
-     */
-    public function user()
-    {
-        return $this->user;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * A convenience method to grab the current user's ID.
-     *
-     * @return int|null
-     */
-    public function id()
-    {
-        if (! is_array($this->user) || empty($this->user['id']))
-        {
-            return null;
-        }
-
-        return (int)$this->user['id'];
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Checks to see if the user is currently being throttled.
-     *
-     *  - If they are NOT, will return FALSE.
-     *  - If they ARE, will return the number of seconds until they can try again.
-     *
-     * @param $user
-     * @return mixed
-     */
-    public function isThrottled($user)
-    {
-        // Not throttling? Get outta here!
-        if (! config_item('auth.allow_throttling'))
-        {
-            return false;
-        }
-
-        // Get user_id
-        $user_id = $user ? $user['id'] : null;
+	protected $ci;
+
+	protected $user = null;
+
+	public $user_model = null;
+
+	public $error = null;
+
+	//--------------------------------------------------------------------
+
+	public function __construct( $ci=null )
+	{
+		if ($ci)
+		{
+			$this->ci= $ci;
+		}
+		else
+		{
+			$this->ci =& get_instance();
+		}
+
+		// Get our compatibility password file loaded up.
+		if (! function_exists('password_hash'))
+		{
+			require_once dirname(__FILE__) .'password.php';
+		}
+
+		if (empty($this->ci->session))
+		{
+			$this->ci->load->library('session');
+		}
+
+		$this->ci->config->load('auth');
+		$this->ci->load->model('auth/login_model');
+		$this->ci->load->language('auth/auth');
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Attempt to log a user into the system.
+	 *
+	 * $credentials is an array of key/value pairs needed to log the user in.
+	 * This is often email/password, or username/password.
+	 *
+	 * @param array $credentials
+	 * @param bool  $remember
+	 * @return bool|mixed
+	 */
+	public function login($credentials, $remember=false)
+	{
+		$user = $this->validate($credentials, true);
+
+		if (! $user)
+		{
+			$this->user = null;
+			return $user;
+		}       
+
+		$this->loginUser($user);
+
+		if ($remember)
+		{
+			$this->rememberUser($user);
+		}
+
+		Events::trigger('didLogin', [$user]);
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Validates user login information without logging them in.
+	 *
+	 * $credentials is an array of key/value pairs needed to log the user in.
+	 * This is often email/password, or username/password.
+	 *
+	 * @param $credentials
+	 * @param bool $return_user
+	 * @return mixed
+	 */
+	public function validate($credentials, $return_user=false)
+	{
+		// Can't validate without a password.
+		if (empty($credentials['password']) || count($credentials) < 2)
+		{
+			return null;
+		}
+
+		$password = $credentials['password'];
+		unset($credentials['password']);
+
+		// We should only be allowed 1 single other credential to
+		// test against.
+		if (count($credentials) > 1)
+		{
+			$this->error = lang('auth.too_many_credentials');
+			return false;
+		}
+
+		// Ensure that the fields are allowed validation fields
+		if (! in_array(key($credentials), config_item('auth.valid_fields')) )
+		{
+			$this->error = lang('auth.invalid_credentials');
+			return false;
+		}
+
+		// We do not want to force case-sensitivity on things
+		// like username and email for usability sake.
+		if (! empty($credentials['email']))
+		{
+			$credentials['email'] = strtolower($credentials['email']);
+		}
+
+		// Can we find a user with those credentials?
+		$user = $this->user_model->as_array()
+								 ->where($credentials)
+								 ->first();
+
+		// If the user is throttled due to too many invalid logins
+		// or the system is under attack, kick them back.
+
+		// If throttling time is above zero, we can't allow
+		// logins now.
+		$time = (int)$this->isThrottled($user);
+		if ($time > 0)
+		{
+			$this->error = sprintf(lang('auth.throttled'), $time);
+			return false;
+		}
+
+		// Get ip address
+		$ip_address = $this->ci->input->ip_address();
+
+		if (! $user)
+		{
+			$this->error = lang('auth.invalid_user');
+			$this->ci->login_model->recordLoginAttempt($ip_address);
+			return false;
+		}
+
+		// Now, try matching the passwords.
+		$result =  password_verify($password, $user['password_hash']);
+
+		if (! $result)
+		{
+			$this->error = lang('auth.invalid_password');
+			$this->ci->login_model->recordLoginAttempt($ip_address, $user['id']);
+			return false;
+		}
+
+		// Check to see if the password needs to be rehashed.
+		// This would be due to the hash algorithm or hash
+		// cost changing since the last time that a user
+		// logged in.
+		if (password_needs_rehash($user['password_hash'], PASSWORD_DEFAULT, ['cost' => config_item('auth.hash_cost')] ))
+		{
+			$new_hash = Password::hashPassword($password);
+			$this->user_model->skip_validation()
+							 ->update($user['id'], ['password_hash' => $new_hash]);
+			unset($new_hash);
+		}
+
+		// Is the user active?
+		if (! $user['active'])
+		{
+			$this->error = lang('auth.inactive_account');
+			return false;
+		}
+
+		return $return_user ? $user : true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Logs a user out and removes all session information.
+	 *
+	 * @return mixed
+	 */
+	public function logout()
+	{
+		$this->ci->load->helper('cookie');
+
+		if (! Events::trigger('beforeLogout', [$this->user]))
+		{
+			return false;
+		}
+
+		// Destroy the session data - but ensure a session is still
+		// available for flash messages, etc.
+		if (isset($_SESSION))
+		{
+			foreach ( $_SESSION as $key => $value )
+			{
+				$_SESSION[ $key ] = NULL;
+				unset( $_SESSION[ $key ] );
+			}
+		}
+		// Also, regenerate the session ID for a touch of added safety.
+		$this->ci->session->sess_regenerate(true);
+
+		// Take care of any rememberme functionality.
+		if (config_item('auth.allow_remembering'))
+		{
+			$token = get_cookie('remember');
+
+			$this->invalidateRememberCookie($this->user['email'], $token);
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Checks whether a user is logged in or not.
+	 *
+	 * @return bool
+	 */
+	public function isLoggedIn()
+	{
+		$id = $this->ci->session->userdata('logged_in');
+
+		if (! $id)
+		{
+			return false;
+		}
+
+		// If the user var hasn't been filled in, we need to fill it in,
+		// since this method will typically be used as the only method
+		// to determine whether a user is logged in or not.
+		if (! $this->user)
+		{
+			$this->user = $this->user_model->as_array()
+										   ->find_by('id', (int)$id);
+
+			if (empty($this->user))
+			{
+				return false;
+			}
+		}
+
+		// If logged in, ensure cache control
+		// headers are in place
+		$this->setHeaders();
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Attempts to log a user in based on the "remember me" cookie.
+	 *
+	 * @return bool
+	 */
+	public function viaRemember()
+	{
+		if (! config_item('auth.allow_remembering'))
+		{
+			return false;
+		}
+
+		$this->ci->load->helper('cookie');
+
+		if (! $token = get_cookie('remember'))
+		{
+			return false;
+		}
+
+		// Attempt to match the token against our auth_tokens table.
+		$query = $this->ci->db->where('hash', $this->ci->login_model->hashRememberToken($token))
+							  ->get('auth_tokens');
+
+		if (! $query->num_rows())
+		{
+			return false;
+		}
+
+		// Grab the user
+		$email = $query->row()->email;
+
+		$user = $this->user_model->as_array()
+								 ->find_by('email', $email);
+
+		$this->loginUser($user);
+
+		// We only want our remember me tokens to be valid
+		// for a single use.
+		$this->refreshRememberCookie($user, $token);
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Registers a new user and handles activation method.
+	 *
+	 * @param $user_data
+	 * @return bool
+	 */
+	public function registerUser($user_data)
+	{
+		// Anything special needed for Activation?
+		$method = config_item('auth.activation_method');
+
+		$user_data['active'] = $method == 'auto' ? 1 : 0;
+
+		// If via email, we need to generate a hash
+		$this->ci->load->helper('string');
+		$token = random_string('alnum', 24);
+		$user_data['activate_hash'] = hash('sha1', config_item('auth.salt') . $token);
+
+		// Email should NOT be case sensitive.
+		if (! empty($user_data['email']))
+		{
+			$user_data['email'] = strtolower($user_data['email']);
+		}
+
+		// Save the user
+		if (! $id = $this->user_model->insert($user_data))
+		{
+			$this->error = $this->user_model->error();
+			return false;
+		}
+
+		$data = [
+			'user_id' => $id,
+			'email'   => $user_data['email'],
+			'token'   => $token,
+			'method'  => $method
+		];
+
+		Events::trigger('didRegisterUser', [$data]);
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Used to verify the user values and activate a user so they can
+	 * visit the site.
+	 *
+	 * @param $data
+	 * @return bool
+	 */
+	public function activateUser($data)
+	{
+		$post = [
+			'email'         => $data['email'],
+			'activate_hash' => hash('sha1', config_item('auth.salt') . $data['code'])
+		];
+
+		$user = $this->user_model->where($post)
+								 ->first();
+
+		if (! $user) {
+			$this->error = $this->user_model->error() ? $this->user_model->error() : lang('auth.activate_no_user');
+
+			return false;
+		}
+
+		if (! $this->user_model->update($user->id, ['active' => 1, 'activate_hash' => null]))
+		{
+			$this->error = $this->user_model->error();
+			return false;
+		}
+
+		Events::trigger('didActivate', [(array)$user]);
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Used to allow manual activation of a user with a known ID.
+	 *
+	 * @param $id
+	 * @return bool
+	 */
+	public function activateUserById($id)
+	{
+		if (! $this->user_model->update($id, ['active' => 1, 'activate_hash' => null]))
+		{
+			$this->error = $this->user_model->error();
+			return false;
+		}
+
+		Events::trigger('didActivate', [$this->user_model->as_array()->find($id)]);
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Grabs the current user object. Returns NULL if nothing found.
+	 *
+	 * @return array|null
+	 */
+	public function user()
+	{
+		return $this->user;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * A convenience method to grab the current user's ID.
+	 *
+	 * @return int|null
+	 */
+	public function id()
+	{
+		if (! is_array($this->user) || empty($this->user['id']))
+		{
+			return null;
+		}
+
+		return (int)$this->user['id'];
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Checks to see if the user is currently being throttled.
+	 *
+	 *  - If they are NOT, will return FALSE.
+	 *  - If they ARE, will return the number of seconds until they can try again.
+	 *
+	 * @param $user
+	 * @return mixed
+	 */
+	public function isThrottled($user)
+	{
+		// Not throttling? Get outta here!
+		if (! config_item('auth.allow_throttling'))
+		{
+			return false;
+		}
+
+		// Get user_id
+		$user_id = $user ? $user['id'] : null;
         
-        // Get ip address
-        $ip_address = $this->ci->input->ip_address();
-
-        // Have any attempts been made?
-        $attempts = $this->ci->login_model->countLoginAttempts($ip_address, $user_id);
-
-        // Grab the amount of time to add if the system thinks we're
-        // under a distributed brute force attack.
-        // Affect users that have at least 1 failure login attempt
-        $dbrute_time = ($attempts === 0) ? 0 : $this->ci->login_model->distributedBruteForceTime();
-
-        // If this user was found to possibly be under a brute
-        // force attack, their account would have been banned
-        // for 15 minutes.
-        if ($time = isset($_SESSION['bruteBan']) ? $_SESSION['bruteBan'] : false)
-        {
-            // If the current time is less than the
-            // the ban expiration, plus any distributed time
-            // then the user can't login just yet.
-            if ($time + $dbrute_time > time())
-            {
-                // The user is banned still...
-                $this->error = lang('auth.bruteBan_notice');
-                return ($time + $dbrute_time) - time();
-            }
-
-            // Still here? The the ban time is over...
-            unset($_SESSION['bruteBan']);
-        }
-
-        // Grab the time of last attempt and
-        // determine if we're throttled by amount of time passed.
-        $last_time = $this->ci->login_model->lastLoginAttemptTime($ip_address, $user_id);
-
-        $allowed = config_item('auth.allowed_login_attempts');
-
-        // We're not throttling if there are 0 attempts or
-        // the number is less than or equal to the allowed free attempts
-        if ($attempts === 0 || $attempts < $allowed)
-        {
-            // Before we can say there's nothing up here,
-            // we need to check dbrute time.
-            $time_left = $last_time + $dbrute_time - time();
-
-            if ($time_left > 0)
-            {
-                return $time_left;
-            }
-
-            return false;
-        }
-
-        // If the number of attempts is excessive (above 100) we need
-        // to check the elapsed time of all of these attacks. If they are
-        // less than 1 minute it's obvious this is a brute force attack,
-        // so we'll set a session flag and block that user for 15 minutes.
-        if ($attempts > 100 && $this->ci->login_model->isBruteForced($ip_address, $user_id))
-        {
-            $this->error = lang('auth.bruteBan_notice');
-
-            $ban_time = 60 * 15;    // 15 minutes
-            $_SESSION['bruteBan'] = time() + $ban_time;
-            return $ban_time;
-        }
-
-        // Get our allowed attempts out of the picture.
-        $attempts = $attempts - $allowed;
-
-        $max_time = config_item('auth.max_throttle_time');
-
-        $add_time = 5 * pow(2, $attempts);
-
-        if ($add_time > $max_time)
-        {
-            $add_time = $max_time;
-        }
-
-        $next_time = $last_time + $add_time + $dbrute_time;
-
-        $current = time();
-
-        // We are NOT throttled if we are already
-        // past the allowed time.
-        if ($current > $next_time)
-        {
-            return false;
-        }
-
-        return $next_time - $current;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Sends a password reset link email to the user associated with
-     * the passed in $email.
-     *
-     * @param $email
-     * @return mixed
-     */
-    public function remindUser($email)
-    {
-        // Emails should NOT be case sensitive.
-        $email = strtolower($email);
-
-        // Is it a valid user?
-        $user = $this->user_model->find_by('email', $email);
-
-        if (! $user)
-        {
-            $this->error = lang('auth.invalid_email');
-            return false;
-        }
-
-        // Generate/store our codes
-        $this->ci->load->helper('string');
-        $token = random_string('alnum', 24);
-        $hash = hash('sha1', config_item('auth.salt') .$token);
-
-        $result = $this->user_model->update($user->id, ['reset_hash' => $hash]);
-
-        if (! $result)
-        {
-            $this->error = $this->user_model->error();
-            return false;
-        }
-
-        Events::trigger('didRemindUser', [(array)$user, $token]);
-
-        return true;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Validates the credentials provided and, if valid, resets the password.
-     *
-     * The $credentials array MUST contain a 'code' key with the string to
-     * hash and check against the reset_hash.
-     *
-     * @param $credentials
-     * @param $password
-     * @param $passConfirm
-     * @return mixed
-     */
-    public function resetPassword($credentials, $password, $passConfirm)
-    {
-        if (empty($credentials['code']))
-        {
-            $this->error = lang('auth.need_reset_code');
-            return false;
-        }
-
-        // Generate a hash to match against the table.
-        $reset_hash = hash('sha1', config_item('auth.salt') .$credentials['code']);
-        unset($credentials['code']);
-
-        if (! empty($credentials['email']))
-        {
-            $credentials['email'] = strtolower($credentials['email']);
-        }
-
-        // Is there a matching user?
-        $user = $this->user_model->as_array()
-                                 ->where($credentials)
-                                 ->first();
-
-        // If throttling time is above zero, we can't allow
-        // logins now.
-        $time = (int)$this->isThrottled($user);
-        if ($time > 0)
-        {
-            $this->error = sprintf(lang('auth.throttled'), $time);
-            return false;
-        }
-
-        // Get ip address
-        $ip_address = $this->ci->input->ip_address();
-
-        if (! $user)
-        {
-            $this->error = lang('auth.reset_no_user');
-            $this->ci->login_model->recordLoginAttempt($ip_address);
-            return false;
-        }
-
-        // Is generated reset_hash string matches one from the table?
-        if ($reset_hash !== $user['reset_hash'])
-        {
-            $this->error = lang('auth.reset_no_user');
-            $this->ci->login_model->recordLoginAttempt($ip_address, $user['id']);
-            return false;
-        }
-
-        // Update their password and reset their reset_hash
-        $data = [
-            'password'     => $password,
-            'pass_confirm' => $passConfirm,
-            'reset_hash'   => null
-        ];
-
-        if (! $this->user_model->update($user['id'], $data))
-        {
-            $this->error = $this->user_model->error();
-            return false;
-        }
-
-        // Clear our login attempts
-        $this->ci->login_model->purgeLoginAttempts($ip_address, $user['id']);
-
-        Events::trigger('didResetPassword', [$user]);
-
-        return true;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Provides a way for implementations to allow new statuses to be set
-     * on the user. The details will vary based upon implementation, but
-     * will often allow for banning or suspending users.
-     *
-     * @param $newStatus
-     * @param null $message
-     * @return mixed
-     */
-    public function changeStatus($newStatus, $message=null)
-    {
-        // todo actually record new users status!
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Allows the consuming application to pass in a reference to the
-     * model that should be used.
-     *
-     * The model MUST extend Myth\Models\CIDbModel.
-     *
-     * @param $model
-     * @param bool $allow_any_parent
-     * @return mixed
-     */
-    public function useModel($model, $allow_any_parent=false)
-    {
-        if (! $allow_any_parent && get_parent_class($model) != 'Myth\Models\CIDbModel')
-        {
-            throw new \RuntimeException('Models passed into LocalAuthenticate MUST extend Myth\Models\CIDbModel');
-        }
-
-        $this->user_model =& $model;
-
-        return $this;
-    }
-
-    //--------------------------------------------------------------------
-
-    public function error()
-    {
-        if (validation_errors())
-        {
-            return validation_errors();
-        }
-
-        return $this->error;
-    }
-
-    //--------------------------------------------------------------------
-
-    //--------------------------------------------------------------------
-    // Login Records
-    //--------------------------------------------------------------------
-
-    /**
-     * Purges all login attempt records from the database.
-     *
-     * @param null $ip_address
-     * @param null $user_id
-     */
-    public function purgeLoginAttempts($ip_address = null, $user_id = null)
-    {
-        $this->ci->login_model->purgeLoginAttempts($ip_address, $user_id);
-
-        // @todo record activity of login attempts purge.
-        Events::trigger('didPurgeLoginAttempts', [$email]);
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Purges all remember tokens for a single user. Effectively logs
-     * a user out of all devices. Intended to allow users to log themselves
-     * out of all devices as a security measure.
-     *
-     * @param $email
-     */
-    public function purgeRememberTokens($email)
-    {
-        // Emails should NOT be case sensitive.
-        $email = strtolower($email);
-
-        $this->ci->login_model->purgeRememberTokens($email);
-
-        // todo record activity of remember me purges.
-        Events::trigger('didPurgeRememberTokens', [$email]);
-    }
-
-    //--------------------------------------------------------------------
-
-    //--------------------------------------------------------------------
-    // Protected Methods
-    //--------------------------------------------------------------------
-
-    /**
-     * Check if Allow Persistent Login Cookies is enable
-     *
-     * @param $user
-     */
-    protected function rememberUser($user)
-    {
-        if (! config_item('auth.allow_remembering'))
-        {
-            log_message('debug', 'Auth library set to refuse "Remember Me" functionality.');
-            return false;
-        }
-
-        $this->refreshRememberCookie($user);
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Invalidates the current rememberme cookie/database entry, creates
-     * a new one, stores it and returns the new value.
-     *
-     * @param $user
-     * @param null $token
-     * @return mixed
-     */
-    protected function refreshRememberCookie($user, $token=null)
-    {
-        $this->ci->load->helper('cookie');
-
-        // If a token is passed in, we know we're removing the
-        // old one.
-        if (! empty($token))
-        {
-            $this->invalidateRememberCookie($user['email'], $token);
-        }
-
-        $new_token = $this->ci->login_model->generateRememberToken($user);
-
-        // Save the token to the database.
-        $data = [
-            'email'   => $user['email'],
-            'hash'    => sha1(config_item('auth.salt') . $new_token),
-            'created' => date('Y-m-d H:i:s')
-        ];
-
-        $this->ci->db->insert('auth_tokens', $data);
-
-        // Create the cookie
-        set_cookie(
-            'remember',                             // Cookie Name
-            $new_token,                             // Value
-            config_item('auth.remember_length'),    // # Seconds until it expires
-            config_item('cookie_domain'),
-            config_item('cookie_path'),
-            config_item('cookie_prefix'),
-            false,                                  // Only send over HTTPS?
-            true                                    // Hide from Javascript?
-        );
-
-        return $new_token;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Deletes any current remember me cookies and database entries.
-     *
-     * @param $email
-     * @param $token
-     * @return string The new token (not the hash).
-     */
-    protected function invalidateRememberCookie($email, $token)
-    {
-        // Emails should NOT be case sensitive.
-        $email = strtolower($email);
-
-        // Remove from the database
-        $this->ci->login_model->deleteRememberToken($email, $token);
-
-        // Remove the cookie
-        delete_cookie(
-            'remember',
-            config_item('cookie_domain'),
-            config_item('cookie_path'),
-            config_item('cookie_prefix')
-        );
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Handles the nitty gritty of actually logging our user into the system.
-     * Does NOT perform the authentication, just sets the system up so that
-     * it knows we're here.
-     *
-     * @param $user
-     */
-    protected function loginUser($user)
-    {
-        // Save the user for later access
-        $this->user = $user;
-
-        // Get ip address
-        $ip_address = $this->ci->input->ip_address();
-
-        // Regenerate the session ID to help protect
-        // against session fixation
-        $this->ci->session->sess_regenerate();
-
-        // Let the session know that we're logged in.
-        $this->ci->session->set_userdata('logged_in', $user['id']);
-
-        // Clear our login attempts
-        $this->ci->login_model->purgeLoginAttempts($ip_address, $user['id']);
-
-        // Record a new Login
-        $this->ci->login_model->recordLogin($user);
-
-        // If logged in, ensure cache control
-        // headers are in place
-        $this->setHeaders();
-
-        // We'll give a 20% chance to need to do a purge since we
-        // don't need to purge THAT often, it's just a maintenance issue.
-        // to keep the table from getting out of control.
-        if (mt_rand(1, 100) < 20)
-        {
-            $this->ci->login_model->purgeOldRememberTokens();
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Sets the headers to ensure that pages are not cached when a user
-     * is logged in, helping to protect against logging out and then
-     * simply hitting the Back button on the browser and getting private
-     * information because the page was loaded from cache.
-     */
-    protected function setHeaders()
-    {
-        $this->ci->output->set_header('Cache-Control: no-store, no-cache, must-revalidate');
-        $this->ci->output->set_header('Cache-Control: post-check=0, pre-check=0');
-        $this->ci->output->set_header('Pragma: no-cache');
-    }
-
-    //--------------------------------------------------------------------
+		// Get ip address
+		$ip_address = $this->ci->input->ip_address();
+
+		// Have any attempts been made?
+		$attempts = $this->ci->login_model->countLoginAttempts($ip_address, $user_id);
+
+		// Grab the amount of time to add if the system thinks we're
+		// under a distributed brute force attack.
+		// Affect users that have at least 1 failure login attempt
+		$dbrute_time = ($attempts === 0) ? 0 : $this->ci->login_model->distributedBruteForceTime();
+
+		// If this user was found to possibly be under a brute
+		// force attack, their account would have been banned
+		// for 15 minutes.
+		if ($time = isset($_SESSION['bruteBan']) ? $_SESSION['bruteBan'] : false)
+		{
+			// If the current time is less than the
+			// the ban expiration, plus any distributed time
+			// then the user can't login just yet.
+			if ($time + $dbrute_time > time())
+			{
+				// The user is banned still...
+				$this->error = lang('auth.bruteBan_notice');
+				return ($time + $dbrute_time) - time();
+			}
+
+			// Still here? The the ban time is over...
+			unset($_SESSION['bruteBan']);
+		}
+
+		// Grab the time of last attempt and
+		// determine if we're throttled by amount of time passed.
+		$last_time = $this->ci->login_model->lastLoginAttemptTime($ip_address, $user_id);
+
+		$allowed = config_item('auth.allowed_login_attempts');
+
+		// We're not throttling if there are 0 attempts or
+		// the number is less than or equal to the allowed free attempts
+		if ($attempts === 0 || $attempts < $allowed)
+		{
+			// Before we can say there's nothing up here,
+			// we need to check dbrute time.
+			$time_left = $last_time + $dbrute_time - time();
+
+			if ($time_left > 0)
+			{
+				return $time_left;
+			}
+
+			return false;
+		}
+
+		// If the number of attempts is excessive (above 100) we need
+		// to check the elapsed time of all of these attacks. If they are
+		// less than 1 minute it's obvious this is a brute force attack,
+		// so we'll set a session flag and block that user for 15 minutes.
+		if ($attempts > 100 && $this->ci->login_model->isBruteForced($ip_address, $user_id))
+		{
+			$this->error = lang('auth.bruteBan_notice');
+
+			$ban_time = 60 * 15;    // 15 minutes
+			$_SESSION['bruteBan'] = time() + $ban_time;
+			return $ban_time;
+		}
+
+		// Get our allowed attempts out of the picture.
+		$attempts = $attempts - $allowed;
+
+		$max_time = config_item('auth.max_throttle_time');
+
+		$add_time = 5 * pow(2, $attempts);
+
+		if ($add_time > $max_time)
+		{
+			$add_time = $max_time;
+		}
+
+		$next_time = $last_time + $add_time + $dbrute_time;
+
+		$current = time();
+
+		// We are NOT throttled if we are already
+		// past the allowed time.
+		if ($current > $next_time)
+		{
+			return false;
+		}
+
+		return $next_time - $current;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Sends a password reset link email to the user associated with
+	 * the passed in $email.
+	 *
+	 * @param $email
+	 * @return mixed
+	 */
+	public function remindUser($email)
+	{
+		// Emails should NOT be case sensitive.
+		$email = strtolower($email);
+
+		// Is it a valid user?
+		$user = $this->user_model->find_by('email', $email);
+
+		if (! $user)
+		{
+			$this->error = lang('auth.invalid_email');
+			return false;
+		}
+
+		// Generate/store our codes
+		$this->ci->load->helper('string');
+		$token = random_string('alnum', 24);
+		$hash = hash('sha1', config_item('auth.salt') .$token);
+
+		$result = $this->user_model->update($user->id, ['reset_hash' => $hash]);
+
+		if (! $result)
+		{
+			$this->error = $this->user_model->error();
+			return false;
+		}
+
+		Events::trigger('didRemindUser', [(array)$user, $token]);
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Validates the credentials provided and, if valid, resets the password.
+	 *
+	 * The $credentials array MUST contain a 'code' key with the string to
+	 * hash and check against the reset_hash.
+	 *
+	 * @param $credentials
+	 * @param $password
+	 * @param $passConfirm
+	 * @return mixed
+	 */
+	public function resetPassword($credentials, $password, $passConfirm)
+	{
+		if (empty($credentials['code']))
+		{
+			$this->error = lang('auth.need_reset_code');
+			return false;
+		}
+
+		// Generate a hash to match against the table.
+		$reset_hash = hash('sha1', config_item('auth.salt') .$credentials['code']);
+		unset($credentials['code']);
+
+		if (! empty($credentials['email']))
+		{
+			$credentials['email'] = strtolower($credentials['email']);
+		}
+
+		// Is there a matching user?
+		$user = $this->user_model->as_array()
+								 ->where($credentials)
+								 ->first();
+
+		// If throttling time is above zero, we can't allow
+		// logins now.
+		$time = (int)$this->isThrottled($user);
+		if ($time > 0)
+		{
+			$this->error = sprintf(lang('auth.throttled'), $time);
+			return false;
+		}
+
+		// Get ip address
+		$ip_address = $this->ci->input->ip_address();
+
+		if (! $user)
+		{
+			$this->error = lang('auth.reset_no_user');
+			$this->ci->login_model->recordLoginAttempt($ip_address);
+			return false;
+		}
+
+		// Is generated reset_hash string matches one from the table?
+		if ($reset_hash !== $user['reset_hash'])
+		{
+			$this->error = lang('auth.reset_no_user');
+			$this->ci->login_model->recordLoginAttempt($ip_address, $user['id']);
+			return false;
+		}
+
+		// Update their password and reset their reset_hash
+		$data = [
+			'password'     => $password,
+			'pass_confirm' => $passConfirm,
+			'reset_hash'   => null
+		];
+
+		if (! $this->user_model->update($user['id'], $data))
+		{
+			$this->error = $this->user_model->error();
+			return false;
+		}
+
+		// Clear our login attempts
+		$this->ci->login_model->purgeLoginAttempts($ip_address, $user['id']);
+
+		Events::trigger('didResetPassword', [$user]);
+
+		return true;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Provides a way for implementations to allow new statuses to be set
+	 * on the user. The details will vary based upon implementation, but
+	 * will often allow for banning or suspending users.
+	 *
+	 * @param $newStatus
+	 * @param null $message
+	 * @return mixed
+	 */
+	public function changeStatus($newStatus, $message=null)
+	{
+		// todo actually record new users status!
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Allows the consuming application to pass in a reference to the
+	 * model that should be used.
+	 *
+	 * The model MUST extend Myth\Models\CIDbModel.
+	 *
+	 * @param $model
+	 * @param bool $allow_any_parent
+	 * @return mixed
+	 */
+	public function useModel($model, $allow_any_parent=false)
+	{
+		if (! $allow_any_parent && get_parent_class($model) != 'Myth\Models\CIDbModel')
+		{
+			throw new \RuntimeException('Models passed into LocalAuthenticate MUST extend Myth\Models\CIDbModel');
+		}
+
+		$this->user_model =& $model;
+
+		return $this;
+	}
+
+	//--------------------------------------------------------------------
+
+	public function error()
+	{
+		if (validation_errors())
+		{
+			return validation_errors();
+		}
+
+		return $this->error;
+	}
+
+	//--------------------------------------------------------------------
+
+	//--------------------------------------------------------------------
+	// Login Records
+	//--------------------------------------------------------------------
+
+	/**
+	 * Purges all login attempt records from the database.
+	 *
+	 * @param null $ip_address
+	 * @param null $user_id
+	 */
+	public function purgeLoginAttempts($ip_address = null, $user_id = null)
+	{
+		$this->ci->login_model->purgeLoginAttempts($ip_address, $user_id);
+
+		// @todo record activity of login attempts purge.
+		Events::trigger('didPurgeLoginAttempts', [$email]);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Purges all remember tokens for a single user. Effectively logs
+	 * a user out of all devices. Intended to allow users to log themselves
+	 * out of all devices as a security measure.
+	 *
+	 * @param $email
+	 */
+	public function purgeRememberTokens($email)
+	{
+		// Emails should NOT be case sensitive.
+		$email = strtolower($email);
+
+		$this->ci->login_model->purgeRememberTokens($email);
+
+		// todo record activity of remember me purges.
+		Events::trigger('didPurgeRememberTokens', [$email]);
+	}
+
+	//--------------------------------------------------------------------
+
+	//--------------------------------------------------------------------
+	// Protected Methods
+	//--------------------------------------------------------------------
+
+	/**
+	 * Check if Allow Persistent Login Cookies is enable
+	 *
+	 * @param $user
+	 */
+	protected function rememberUser($user)
+	{
+		if (! config_item('auth.allow_remembering'))
+		{
+			log_message('debug', 'Auth library set to refuse "Remember Me" functionality.');
+			return false;
+		}
+
+		$this->refreshRememberCookie($user);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Invalidates the current rememberme cookie/database entry, creates
+	 * a new one, stores it and returns the new value.
+	 *
+	 * @param $user
+	 * @param null $token
+	 * @return mixed
+	 */
+	protected function refreshRememberCookie($user, $token=null)
+	{
+		$this->ci->load->helper('cookie');
+
+		// If a token is passed in, we know we're removing the
+		// old one.
+		if (! empty($token))
+		{
+			$this->invalidateRememberCookie($user['email'], $token);
+		}
+
+		$new_token = $this->ci->login_model->generateRememberToken($user);
+
+		// Save the token to the database.
+		$data = [
+			'email'   => $user['email'],
+			'hash'    => sha1(config_item('auth.salt') . $new_token),
+			'created' => date('Y-m-d H:i:s')
+		];
+
+		$this->ci->db->insert('auth_tokens', $data);
+
+		// Create the cookie
+		set_cookie(
+			'remember',                             // Cookie Name
+			$new_token,                             // Value
+			config_item('auth.remember_length'),    // # Seconds until it expires
+			config_item('cookie_domain'),
+			config_item('cookie_path'),
+			config_item('cookie_prefix'),
+			false,                                  // Only send over HTTPS?
+			true                                    // Hide from Javascript?
+		);
+
+		return $new_token;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Deletes any current remember me cookies and database entries.
+	 *
+	 * @param $email
+	 * @param $token
+	 * @return string The new token (not the hash).
+	 */
+	protected function invalidateRememberCookie($email, $token)
+	{
+		// Emails should NOT be case sensitive.
+		$email = strtolower($email);
+
+		// Remove from the database
+		$this->ci->login_model->deleteRememberToken($email, $token);
+
+		// Remove the cookie
+		delete_cookie(
+			'remember',
+			config_item('cookie_domain'),
+			config_item('cookie_path'),
+			config_item('cookie_prefix')
+		);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Handles the nitty gritty of actually logging our user into the system.
+	 * Does NOT perform the authentication, just sets the system up so that
+	 * it knows we're here.
+	 *
+	 * @param $user
+	 */
+	protected function loginUser($user)
+	{
+		// Save the user for later access
+		$this->user = $user;
+
+		// Get ip address
+		$ip_address = $this->ci->input->ip_address();
+
+		// Regenerate the session ID to help protect
+		// against session fixation
+		$this->ci->session->sess_regenerate();
+
+		// Let the session know that we're logged in.
+		$this->ci->session->set_userdata('logged_in', $user['id']);
+
+		// Clear our login attempts
+		$this->ci->login_model->purgeLoginAttempts($ip_address, $user['id']);
+
+		// Record a new Login
+		$this->ci->login_model->recordLogin($user);
+
+		// If logged in, ensure cache control
+		// headers are in place
+		$this->setHeaders();
+
+		// We'll give a 20% chance to need to do a purge since we
+		// don't need to purge THAT often, it's just a maintenance issue.
+		// to keep the table from getting out of control.
+		if (mt_rand(1, 100) < 20)
+		{
+			$this->ci->login_model->purgeOldRememberTokens();
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Sets the headers to ensure that pages are not cached when a user
+	 * is logged in, helping to protect against logging out and then
+	 * simply hitting the Back button on the browser and getting private
+	 * information because the page was loaded from cache.
+	 */
+	protected function setHeaders()
+	{
+		$this->ci->output->set_header('Cache-Control: no-store, no-cache, must-revalidate');
+		$this->ci->output->set_header('Cache-Control: post-check=0, pre-check=0');
+		$this->ci->output->set_header('Pragma: no-cache');
+	}
+
+	//--------------------------------------------------------------------
 
 
 }

myth/Route.php

Indentation +639 added lines, -639 removed lines

@@ -43,644 +43,644 @@
 class Route
 {
 
-    // Our routes, ripe for the picking.
-    public $routes = array();
-
-    // Holds key/value pairs of named routes
-    public static $names = array();
-
-    // Used for grouping routes together.
-    public $group = null;
-
-    // Holds the 'areas' of the site.
-    public static $areas = array();
-
-    // The default controller to use in case
-    // 'default_controller' is not in the routes file.
-    protected $default_home = 'home';
-
-    // The default constraint to use in route building
-    protected $default_constraint = 'any';
-
-    protected $constraints = [
-        'any'  => '(:any)',
-        'num'  => '(:num)',
-        'id'   => '(:num)',
-        'name' => "([a-zA-Z']+)"
-    ];
-
-    protected $current_subdomain = null;
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Combines the routes that we've defined with the Route class with the
-     * routes passed in. This is intended to be used  after all routes have been
-     * defined to merge CI's default $route array with our routes.
-     *
-     * Example:
-     *     $route['default_controller'] = 'home';
-     *     Route::resource('posts');
-     *     $route = Route::map($route);
-     *
-     * @param array $routes
-     * @internal param array $route The array to merge
-     * @return array         The merge route array.
-     */
-    public function map($routes = array())
-    {
-        $controller = isset($routes['default_controller']) ? $routes['default_controller'] : $this->default_home;
-
-        $routes = array_merge($routes, $this->routes);
-
-        foreach ($routes as $from => $to) {
-            $routes[$from] = str_ireplace('{default_controller}', $controller, $to);
-        }
-
-        return $routes;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * A single point to the basic routing. Can be used in place of CI's $route
-     * array if desired. Used internally by many of the methods.
-     *
-     * Available options are currently:
-     *      'as'        - remembers the route via a name that can be called outside of it.
-     *      'offset'    - Offsets and parameters ($1, $2, etc) in routes by the specified amount.
-     *                    Useful while doing versioning of API's, etc.
-     *
-     * Example:
-     *      $route->any('news', 'posts/index');
-     *
-     * @param string $from
-     * @param string $to
-     * @param array  $options
-     * @return void
-     */
-    public function any($from, $to, $options = array())
-    {
-        $this->create($from, $to, $options);
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Sets the default constraint to be used in the system. Typically
-     * for use with the 'resources' method.
-     *
-     * @param $constraint
-     */
-    public function setDefaultConstraint($constraint)
-    {
-        if (array_key_exists($constraint, $this->constraints)) {
-            $this->default_constraint = $constraint;
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Registers a new constraint to be used internally. Useful for creating
-     * very specific regex patterns, or simply to allow your routes to be
-     * a tad more readable.
-     *
-     * Example:
-     *      $route->registerConstraint('hero', '(^.*)');
-     *
-     *      $route->any('home/{hero}', 'heroes/journey');
-     *
-     *      // Route then looks like:
-     *      $route['home/(^.*)'] = 'heroes/journey';
-     *
-     * @param      $name
-     * @param      $pattern
-     * @param bool $overwrite
-     */
-    public function registerConstraint($name, $pattern, $overwrite = false)
-    {
-        // Ensure consistency
-        $name    = trim($name, '{} ');
-        $pattern = '(' . trim($pattern, '() ') . ')';
-
-        // Not here? Add it and leave...
-        if (! array_key_exists($name, $this->constraints)) {
-            $this->constraints[$name] = $pattern;
-
-            return;
-        }
-
-        // Here? Then it exists. Should we overwrite it?
-        if ($overwrite) {
-            $this->constraints[$name] = $pattern;
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    //--------------------------------------------------------------------
-    // Named Routes
-    //--------------------------------------------------------------------
-
-    /**
-     * Returns the value of a named route. Useful for getting named
-     * routes for use while building with site_url() or in templates
-     * where you don't need to instantiate the route class.
-     *
-     * Example:
-     *      $route->any('news', 'posts/index', ['as' => 'blog']);
-     *
-     *      // Returns http://mysite.com/news
-     *      site_url( Route::named('blog') );
-     *
-     * @param  [type] $name [description]
-     * @return [type]       [description]
-     */
-    public static function named($name)
-    {
-        if (isset(self::$names[$name])) {
-            return self::$names[$name];
-        }
-
-        return null;
-    }
-
-    //--------------------------------------------------------------------
-
-    //--------------------------------------------------------------------
-    // Grouping Routes
-    //--------------------------------------------------------------------
-
-    /**
-     * Group a series of routes under a single URL segment. This is handy
-     * for grouping items into an admin area, like:
-     *
-     * Example:
-     *     $route->group('admin', function() {
-     *            $route->resources('users');
-     *     });
-     *
-     * @param  string   $name     The name to group/prefix the routes with.
-     * @param  \Closure $callback An anonymous function that allows you route inside of this group.
-     * @return void
-     */
-    public function group($name, \Closure $callback)
-    {
-        $old_group = $this->group;
-
-        // To register a route, we'll set a flag so that our router
-        // so it will see the groupname.
-        $this->group = ltrim($old_group . '/' . $name, '/');
-
-        call_user_func($callback);
-
-        // Make sure to clear the group name so we don't accidentally
-        // group any ones we didn't want to.
-        $this->group = $old_group;
-    }
-
-    //--------------------------------------------------------------------
-
-    //--------------------------------------------------------------------
-    // HTTP Verb-based routing
-    //--------------------------------------------------------------------
-    // Routing works here because, as the routes config file is read in,
-    // the various HTTP verb-based routes will only be added to the in-memory
-    // routes if it is a call that should respond to that verb.
-    //
-    // The options array is typically used to pass in an 'as' or var, but may
-    // be expanded in the future. See the docblock for 'any' method above for
-    // current list of globally available options.
-    //
-
-    /**
-     * Specifies a single route to match for multiple HTTP Verbs.
-     *
-     * Example:
-     *  $route->match( ['get', 'post'], 'users/(:num)', 'users/$1);
-     *
-     * @param array $verbs
-     * @param       $from
-     * @param       $to
-     * @param array $options
-     */
-    public function match($verbs = [], $from, $to, $options = [])
-    {
-        foreach ($verbs as $verb) {
-            $verb = strtolower($verb);
-
-            $this->{$verb}($from, $to, $options);
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Specifies a route that is only available to GET requests.
-     *
-     * @param       $from
-     * @param       $to
-     * @param array $options
-     */
-    public function get($from, $to, $options = [])
-    {
-        if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] == 'GET') {
-            $this->create($from, $to, $options);
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Specifies a route that is only available to POST requests.
-     *
-     * @param       $from
-     * @param       $to
-     * @param array $options
-     */
-    public function post($from, $to, $options = [])
-    {
-        if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] == 'POST') {
-            $this->create($from, $to, $options);
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Specifies a route that is only available to PUT requests.
-     *
-     * @param       $from
-     * @param       $to
-     * @param array $options
-     */
-    public function put($from, $to, $options = [])
-    {
-        if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] == 'PUT') {
-            $this->create($from, $to, $options);
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Specifies a route that is only available to DELETE requests.
-     *
-     * @param       $from
-     * @param       $to
-     * @param array $options
-     */
-    public function delete($from, $to, $options = [])
-    {
-        if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] == 'DELETE') {
-            $this->create($from, $to, $options);
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Specifies a route that is only available to HEAD requests.
-     *
-     * @param       $from
-     * @param       $to
-     * @param array $options
-     */
-    public function head($from, $to, $options = [])
-    {
-        if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] == 'HEAD') {
-            $this->create($from, $to, $options);
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Specifies a route that is only available to PATCH requests.
-     *
-     * @param       $from
-     * @param       $to
-     * @param array $options
-     */
-    public function patch($from, $to, $options = [])
-    {
-        if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] == 'PATCH') {
-            $this->create($from, $to, $options);
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Specifies a route that is only available to OPTIONS requests.
-     *
-     * @param       $from
-     * @param       $to
-     * @param array $options
-     */
-    public function options($from, $to, $options = [])
-    {
-        if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] == 'OPTIONS') {
-            $this->create($from, $to, $options);
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Creates a collections of HTTP-verb based routes for a controller.
-     *
-     * Possible Options:
-     *      'controller'    - Customize the name of the controller used in the 'to' route
-     *      'module'        - Prepend a module name to the generate 'to' routes
-     *      'constraint'    - The regex used by the Router. Defaults to '(:any)'
-     *
-     * Example:
-     *      $route->resources('photos');
-     *
-     *      // Generates the following routes:
-     *      HTTP Verb | Path        | Action        | Used for...
-     *      ----------+-------------+---------------+-----------------
-     *      GET         /photos             index           display a list of photos
-     *      GET         /photos/new         creation_form   return an HTML form for creating a new photo
-     *      GET         /photos/{id}        show            display a specific photo
-     *      GET         /photos/{id}/edit   editing_form    return an HTML form for editing the photo
-     *      POST        /photos             create          create a new photo
-     *      PUT         /photos/{id}        update          update an existing photo
-     *      DELETE      /photos/{id}/delete delete          delete an existing photo
-     *
-     * @param  string $name    The name of the controller to route to.
-     * @param  array  $options An list of possible ways to customize the routing.
-     */
-    public function resources($name, $options = [])
-    {
-        // In order to allow customization of the route the
-        // resources are sent to, we need to have a new name
-        // to store the values in.
-        $new_name = $name;
-
-        // If a new controller is specified, then we replace the
-        // $name value with the name of the new controller.
-        if (isset($options['controller'])) {
-            $new_name = $options['controller'];
-        }
-
-        // If a new module was specified, simply put that path
-        // in front of the controller.
-        if (isset($options['module'])) {
-            $new_name = $options['module'] . '/' . $new_name;
-        }
-
-        // In order to allow customization of allowed id values
-        // we need someplace to store them.
-        $id = isset($this->constraints[$this->default_constraint]) ? $this->constraints[$this->default_constraint] :
-            '(:any)';
-
-        if (isset($options['constraint'])) {
-            $id = $options['constraint'];
-        }
-
-        $this->get($name, $new_name . '/list_all', $options);
-        $this->get($name . '/' . $id, $new_name . '/show/$1', $options);
-        $this->post($name, $new_name . '/create', $options);
-        $this->put($name . '/' . $id, $new_name . '/update/$1', $options);
-        $this->delete($name . '/' . $id, $new_name . '/delete/$1', $options);
-        $this->options($name, $new_name . '/index', $options);
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Lets the system know about different 'areas' within the site, like
-     * the admin area, that maps to certain controllers.
-     *
-     * @param  string $area       The name of the area.
-     * @param  string $controller The controller name to look for.
-     * @param         $options
-     */
-    public function area($area, $controller = null, $options = [])
-    {
-        // No controller? Match the area name.
-        $controller = is_null($controller) ? $area : $controller;
-
-        // Save the area so we can recognize it later.
-        self::$areas[$area] = $controller;
-
-        // Create routes for this area.
-        $this->create($area . '/(:any)/(:any)/(:any)/(:any)/(:any)', '$1/' . $controller . '/$2/$3/$4/$5', $options);
-        $this->create($area . '/(:any)/(:any)/(:any)/(:any)', '$1/' . $controller . '/$2/$3/$4', $options);
-        $this->create($area . '/(:any)/(:any)/(:any)', '$1/' . $controller . '/$2/$3', $options);
-        $this->create($area . '/(:any)/(:any)', '$1/' . $controller . '/$2', $options);
-        $this->create($area . '/(:any)', '$1/' . $controller, $options);
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Returns the name of the area based on the controller name.
-     *
-     * @param  string $controller The name of the controller
-     * @return string             The name of the corresponding area
-     */
-    public static function getAreaName($controller)
-    {
-        foreach (self::$areas as $area => $cont) {
-            if ($controller == $cont) {
-                return $area;
-            }
-        }
-
-        return null;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Limits the routes to a specified ENVIRONMENT or they won't run.
-     *
-     * @param $env
-     * @param callable $callback
-     *
-     * @return bool|null
-     */
-    public function environment($env, \Closure $callback)
-    {
-        if (ENVIRONMENT == $env)
-        {
-            call_user_func($callback);
-            return true;
-        }
-
-        return null;
-    }
-
-    //--------------------------------------------------------------------
-
-
-
-    /**
-     * Allows you to easily block access to any number of routes by setting
-     * that route to an empty path ('').
-     *
-     * Example:
-     *     Route::block('posts', 'photos/(:num)');
-     *
-     *     // Same as...
-     *     $route['posts']          = '';
-     *     $route['photos/(:num)']  = '';
-     */
-    public function block()
-    {
-        $paths = func_get_args();
-
-        if (! is_array($paths) || ! count($paths)) {
-            return;
-        }
-
-        foreach ($paths as $path) {
-            $this->create($path, '');
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Empties all named and un-named routes from the system.
-     *
-     * @return void
-     */
-    public function reset()
-    {
-        $this->routes = array();
-        $this->group  = null;
-        self::$names  = array();
-        self::$areas  = array();
-    }
-
-    //--------------------------------------------------------------------
-
-    //--------------------------------------------------------------------
-    // Private Methods
-    //--------------------------------------------------------------------
-
-    /**
-     * Does the heavy lifting of creating an actual route. You must specify
-     * the request method(s) that this route will work for. They can be separated
-     * by a pipe character "|" if there is more than one.
-     *
-     * @param  string $from
-     * @param  array  $to
-     * @param array   $options
-     *
-     * @return array          The built route.
-     */
-    private function create($from, $to, $options = array())
-    {
-        $prefix = is_null($this->group) ? '' : $this->group . '/';
-
-        $from = $prefix . $from;
-
-        // Are we saving the name for this one?
-        if (isset($options['as']) && !empty($options['as'])) {
-            self::$names[$options['as']] = $from;
-        }
-
-        // Limiting to subdomains?
-        if (isset($options['subdomain']) && !empty($options['subdomain'])) {
-            // If we don't match the current subdomain, then
-            // we don't need to add the route.
-            if (!$this->checkSubdomains($options['subdomain'])) {
-                return;
-            }
-        }
-
-        // Are we offsetting the parameters?
-        // If so, take care of them here in one
-        // fell swoop.
-        if (isset($options['offset'])) {
-            // Get a constant string to work with.
-            $to = preg_replace('/(\$\d+)/', '$X', $to);
-
-            for ($i = (int)$options['offset'] + 1; $i < (int)$options['offset'] + 7; $i ++) {
-                $to = preg_replace_callback(
-                    '/\$X/',
-                    function ($m) use ($i) {
-                        return '$' . $i;
-                    },
-                    $to,
-                    1
-                );
-            }
-        }
-
-        // Convert any custom constraints to the CI/pattern equivalent
-        foreach ($this->constraints as $name => $pattern) {
-            $from = str_replace('{' . $name . '}', $pattern, $from);
-        }
-
-        $this->routes[$from] = $to;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Compares the subdomain(s) passed in against the current subdomain
-     * on this page request.
-     *
-     * @param $subdomains
-     * @return bool
-     */
-    private function checkSubdomains($subdomains)
-    {
-        if (is_null($this->current_subdomain)) {
-            $this->determineCurrentSubdomain();
-        }
-
-        if (!is_array($subdomains)) {
-            $subdomains = array($subdomains);
-        }
-
-        $matched = false;
-
-        array_walk(
-            $subdomains,
-            function ($subdomain) use (&$matched) {
-                if ($subdomain == $this->current_subdomain || $subdomain == '*') {
-                    $matched = true;
-                }
-            }
-        );
-
-        return $matched;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Examines the HTTP_HOST to get a best match for the subdomain. It
-     * won't be perfect, but should work for our needs.
-     */
-    private function determineCurrentSubdomain()
-    {
-        $parsedUrl = parse_url($_SERVER['HTTP_HOST']);
-
-        $host = explode('.', $parsedUrl['host']);
-
-        // If we only have 2 parts, then we don't have a subdomain.
-        // This won't be totally accurate, since URL's like example.co.uk
-        // would still pass, but it helps to separate the chaff...
-        if (!is_array($host) || count($host) == 2) {
-            // Set it to false so we don't make it back here again.
-            $this->current_subdomain = false;
-            return;
-        }
-
-        // Now, we'll simply take the first element of the array. This should
-        // be fine even in cases like example.co.uk, since they won't be looking
-        // for 'example' when they try to match the subdomain, in most all cases.
-        $this->current_subdomain = array_shift($host);
-    }
-    //--------------------------------------------------------------------
+	// Our routes, ripe for the picking.
+	public $routes = array();
+
+	// Holds key/value pairs of named routes
+	public static $names = array();
+
+	// Used for grouping routes together.
+	public $group = null;
+
+	// Holds the 'areas' of the site.
+	public static $areas = array();
+
+	// The default controller to use in case
+	// 'default_controller' is not in the routes file.
+	protected $default_home = 'home';
+
+	// The default constraint to use in route building
+	protected $default_constraint = 'any';
+
+	protected $constraints = [
+		'any'  => '(:any)',
+		'num'  => '(:num)',
+		'id'   => '(:num)',
+		'name' => "([a-zA-Z']+)"
+	];
+
+	protected $current_subdomain = null;
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Combines the routes that we've defined with the Route class with the
+	 * routes passed in. This is intended to be used  after all routes have been
+	 * defined to merge CI's default $route array with our routes.
+	 *
+	 * Example:
+	 *     $route['default_controller'] = 'home';
+	 *     Route::resource('posts');
+	 *     $route = Route::map($route);
+	 *
+	 * @param array $routes
+	 * @internal param array $route The array to merge
+	 * @return array         The merge route array.
+	 */
+	public function map($routes = array())
+	{
+		$controller = isset($routes['default_controller']) ? $routes['default_controller'] : $this->default_home;
+
+		$routes = array_merge($routes, $this->routes);
+
+		foreach ($routes as $from => $to) {
+			$routes[$from] = str_ireplace('{default_controller}', $controller, $to);
+		}
+
+		return $routes;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * A single point to the basic routing. Can be used in place of CI's $route
+	 * array if desired. Used internally by many of the methods.
+	 *
+	 * Available options are currently:
+	 *      'as'        - remembers the route via a name that can be called outside of it.
+	 *      'offset'    - Offsets and parameters ($1, $2, etc) in routes by the specified amount.
+	 *                    Useful while doing versioning of API's, etc.
+	 *
+	 * Example:
+	 *      $route->any('news', 'posts/index');
+	 *
+	 * @param string $from
+	 * @param string $to
+	 * @param array  $options
+	 * @return void
+	 */
+	public function any($from, $to, $options = array())
+	{
+		$this->create($from, $to, $options);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Sets the default constraint to be used in the system. Typically
+	 * for use with the 'resources' method.
+	 *
+	 * @param $constraint
+	 */
+	public function setDefaultConstraint($constraint)
+	{
+		if (array_key_exists($constraint, $this->constraints)) {
+			$this->default_constraint = $constraint;
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Registers a new constraint to be used internally. Useful for creating
+	 * very specific regex patterns, or simply to allow your routes to be
+	 * a tad more readable.
+	 *
+	 * Example:
+	 *      $route->registerConstraint('hero', '(^.*)');
+	 *
+	 *      $route->any('home/{hero}', 'heroes/journey');
+	 *
+	 *      // Route then looks like:
+	 *      $route['home/(^.*)'] = 'heroes/journey';
+	 *
+	 * @param      $name
+	 * @param      $pattern
+	 * @param bool $overwrite
+	 */
+	public function registerConstraint($name, $pattern, $overwrite = false)
+	{
+		// Ensure consistency
+		$name    = trim($name, '{} ');
+		$pattern = '(' . trim($pattern, '() ') . ')';
+
+		// Not here? Add it and leave...
+		if (! array_key_exists($name, $this->constraints)) {
+			$this->constraints[$name] = $pattern;
+
+			return;
+		}
+
+		// Here? Then it exists. Should we overwrite it?
+		if ($overwrite) {
+			$this->constraints[$name] = $pattern;
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	//--------------------------------------------------------------------
+	// Named Routes
+	//--------------------------------------------------------------------
+
+	/**
+	 * Returns the value of a named route. Useful for getting named
+	 * routes for use while building with site_url() or in templates
+	 * where you don't need to instantiate the route class.
+	 *
+	 * Example:
+	 *      $route->any('news', 'posts/index', ['as' => 'blog']);
+	 *
+	 *      // Returns http://mysite.com/news
+	 *      site_url( Route::named('blog') );
+	 *
+	 * @param  [type] $name [description]
+	 * @return [type]       [description]
+	 */
+	public static function named($name)
+	{
+		if (isset(self::$names[$name])) {
+			return self::$names[$name];
+		}
+
+		return null;
+	}
+
+	//--------------------------------------------------------------------
+
+	//--------------------------------------------------------------------
+	// Grouping Routes
+	//--------------------------------------------------------------------
+
+	/**
+	 * Group a series of routes under a single URL segment. This is handy
+	 * for grouping items into an admin area, like:
+	 *
+	 * Example:
+	 *     $route->group('admin', function() {
+	 *            $route->resources('users');
+	 *     });
+	 *
+	 * @param  string   $name     The name to group/prefix the routes with.
+	 * @param  \Closure $callback An anonymous function that allows you route inside of this group.
+	 * @return void
+	 */
+	public function group($name, \Closure $callback)
+	{
+		$old_group = $this->group;
+
+		// To register a route, we'll set a flag so that our router
+		// so it will see the groupname.
+		$this->group = ltrim($old_group . '/' . $name, '/');
+
+		call_user_func($callback);
+
+		// Make sure to clear the group name so we don't accidentally
+		// group any ones we didn't want to.
+		$this->group = $old_group;
+	}
+
+	//--------------------------------------------------------------------
+
+	//--------------------------------------------------------------------
+	// HTTP Verb-based routing
+	//--------------------------------------------------------------------
+	// Routing works here because, as the routes config file is read in,
+	// the various HTTP verb-based routes will only be added to the in-memory
+	// routes if it is a call that should respond to that verb.
+	//
+	// The options array is typically used to pass in an 'as' or var, but may
+	// be expanded in the future. See the docblock for 'any' method above for
+	// current list of globally available options.
+	//
+
+	/**
+	 * Specifies a single route to match for multiple HTTP Verbs.
+	 *
+	 * Example:
+	 *  $route->match( ['get', 'post'], 'users/(:num)', 'users/$1);
+	 *
+	 * @param array $verbs
+	 * @param       $from
+	 * @param       $to
+	 * @param array $options
+	 */
+	public function match($verbs = [], $from, $to, $options = [])
+	{
+		foreach ($verbs as $verb) {
+			$verb = strtolower($verb);
+
+			$this->{$verb}($from, $to, $options);
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Specifies a route that is only available to GET requests.
+	 *
+	 * @param       $from
+	 * @param       $to
+	 * @param array $options
+	 */
+	public function get($from, $to, $options = [])
+	{
+		if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] == 'GET') {
+			$this->create($from, $to, $options);
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Specifies a route that is only available to POST requests.
+	 *
+	 * @param       $from
+	 * @param       $to
+	 * @param array $options
+	 */
+	public function post($from, $to, $options = [])
+	{
+		if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] == 'POST') {
+			$this->create($from, $to, $options);
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Specifies a route that is only available to PUT requests.
+	 *
+	 * @param       $from
+	 * @param       $to
+	 * @param array $options
+	 */
+	public function put($from, $to, $options = [])
+	{
+		if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] == 'PUT') {
+			$this->create($from, $to, $options);
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Specifies a route that is only available to DELETE requests.
+	 *
+	 * @param       $from
+	 * @param       $to
+	 * @param array $options
+	 */
+	public function delete($from, $to, $options = [])
+	{
+		if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] == 'DELETE') {
+			$this->create($from, $to, $options);
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Specifies a route that is only available to HEAD requests.
+	 *
+	 * @param       $from
+	 * @param       $to
+	 * @param array $options
+	 */
+	public function head($from, $to, $options = [])
+	{
+		if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] == 'HEAD') {
+			$this->create($from, $to, $options);
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Specifies a route that is only available to PATCH requests.
+	 *
+	 * @param       $from
+	 * @param       $to
+	 * @param array $options
+	 */
+	public function patch($from, $to, $options = [])
+	{
+		if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] == 'PATCH') {
+			$this->create($from, $to, $options);
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Specifies a route that is only available to OPTIONS requests.
+	 *
+	 * @param       $from
+	 * @param       $to
+	 * @param array $options
+	 */
+	public function options($from, $to, $options = [])
+	{
+		if (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] == 'OPTIONS') {
+			$this->create($from, $to, $options);
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Creates a collections of HTTP-verb based routes for a controller.
+	 *
+	 * Possible Options:
+	 *      'controller'    - Customize the name of the controller used in the 'to' route
+	 *      'module'        - Prepend a module name to the generate 'to' routes
+	 *      'constraint'    - The regex used by the Router. Defaults to '(:any)'
+	 *
+	 * Example:
+	 *      $route->resources('photos');
+	 *
+	 *      // Generates the following routes:
+	 *      HTTP Verb | Path        | Action        | Used for...
+	 *      ----------+-------------+---------------+-----------------
+	 *      GET         /photos             index           display a list of photos
+	 *      GET         /photos/new         creation_form   return an HTML form for creating a new photo
+	 *      GET         /photos/{id}        show            display a specific photo
+	 *      GET         /photos/{id}/edit   editing_form    return an HTML form for editing the photo
+	 *      POST        /photos             create          create a new photo
+	 *      PUT         /photos/{id}        update          update an existing photo
+	 *      DELETE      /photos/{id}/delete delete          delete an existing photo
+	 *
+	 * @param  string $name    The name of the controller to route to.
+	 * @param  array  $options An list of possible ways to customize the routing.
+	 */
+	public function resources($name, $options = [])
+	{
+		// In order to allow customization of the route the
+		// resources are sent to, we need to have a new name
+		// to store the values in.
+		$new_name = $name;
+
+		// If a new controller is specified, then we replace the
+		// $name value with the name of the new controller.
+		if (isset($options['controller'])) {
+			$new_name = $options['controller'];
+		}
+
+		// If a new module was specified, simply put that path
+		// in front of the controller.
+		if (isset($options['module'])) {
+			$new_name = $options['module'] . '/' . $new_name;
+		}
+
+		// In order to allow customization of allowed id values
+		// we need someplace to store them.
+		$id = isset($this->constraints[$this->default_constraint]) ? $this->constraints[$this->default_constraint] :
+			'(:any)';
+
+		if (isset($options['constraint'])) {
+			$id = $options['constraint'];
+		}
+
+		$this->get($name, $new_name . '/list_all', $options);
+		$this->get($name . '/' . $id, $new_name . '/show/$1', $options);
+		$this->post($name, $new_name . '/create', $options);
+		$this->put($name . '/' . $id, $new_name . '/update/$1', $options);
+		$this->delete($name . '/' . $id, $new_name . '/delete/$1', $options);
+		$this->options($name, $new_name . '/index', $options);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Lets the system know about different 'areas' within the site, like
+	 * the admin area, that maps to certain controllers.
+	 *
+	 * @param  string $area       The name of the area.
+	 * @param  string $controller The controller name to look for.
+	 * @param         $options
+	 */
+	public function area($area, $controller = null, $options = [])
+	{
+		// No controller? Match the area name.
+		$controller = is_null($controller) ? $area : $controller;
+
+		// Save the area so we can recognize it later.
+		self::$areas[$area] = $controller;
+
+		// Create routes for this area.
+		$this->create($area . '/(:any)/(:any)/(:any)/(:any)/(:any)', '$1/' . $controller . '/$2/$3/$4/$5', $options);
+		$this->create($area . '/(:any)/(:any)/(:any)/(:any)', '$1/' . $controller . '/$2/$3/$4', $options);
+		$this->create($area . '/(:any)/(:any)/(:any)', '$1/' . $controller . '/$2/$3', $options);
+		$this->create($area . '/(:any)/(:any)', '$1/' . $controller . '/$2', $options);
+		$this->create($area . '/(:any)', '$1/' . $controller, $options);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Returns the name of the area based on the controller name.
+	 *
+	 * @param  string $controller The name of the controller
+	 * @return string             The name of the corresponding area
+	 */
+	public static function getAreaName($controller)
+	{
+		foreach (self::$areas as $area => $cont) {
+			if ($controller == $cont) {
+				return $area;
+			}
+		}
+
+		return null;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Limits the routes to a specified ENVIRONMENT or they won't run.
+	 *
+	 * @param $env
+	 * @param callable $callback
+	 *
+	 * @return bool|null
+	 */
+	public function environment($env, \Closure $callback)
+	{
+		if (ENVIRONMENT == $env)
+		{
+			call_user_func($callback);
+			return true;
+		}
+
+		return null;
+	}
+
+	//--------------------------------------------------------------------
+
+
+
+	/**
+	 * Allows you to easily block access to any number of routes by setting
+	 * that route to an empty path ('').
+	 *
+	 * Example:
+	 *     Route::block('posts', 'photos/(:num)');
+	 *
+	 *     // Same as...
+	 *     $route['posts']          = '';
+	 *     $route['photos/(:num)']  = '';
+	 */
+	public function block()
+	{
+		$paths = func_get_args();
+
+		if (! is_array($paths) || ! count($paths)) {
+			return;
+		}
+
+		foreach ($paths as $path) {
+			$this->create($path, '');
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Empties all named and un-named routes from the system.
+	 *
+	 * @return void
+	 */
+	public function reset()
+	{
+		$this->routes = array();
+		$this->group  = null;
+		self::$names  = array();
+		self::$areas  = array();
+	}
+
+	//--------------------------------------------------------------------
+
+	//--------------------------------------------------------------------
+	// Private Methods
+	//--------------------------------------------------------------------
+
+	/**
+	 * Does the heavy lifting of creating an actual route. You must specify
+	 * the request method(s) that this route will work for. They can be separated
+	 * by a pipe character "|" if there is more than one.
+	 *
+	 * @param  string $from
+	 * @param  array  $to
+	 * @param array   $options
+	 *
+	 * @return array          The built route.
+	 */
+	private function create($from, $to, $options = array())
+	{
+		$prefix = is_null($this->group) ? '' : $this->group . '/';
+
+		$from = $prefix . $from;
+
+		// Are we saving the name for this one?
+		if (isset($options['as']) && !empty($options['as'])) {
+			self::$names[$options['as']] = $from;
+		}
+
+		// Limiting to subdomains?
+		if (isset($options['subdomain']) && !empty($options['subdomain'])) {
+			// If we don't match the current subdomain, then
+			// we don't need to add the route.
+			if (!$this->checkSubdomains($options['subdomain'])) {
+				return;
+			}
+		}
+
+		// Are we offsetting the parameters?
+		// If so, take care of them here in one
+		// fell swoop.
+		if (isset($options['offset'])) {
+			// Get a constant string to work with.
+			$to = preg_replace('/(\$\d+)/', '$X', $to);
+
+			for ($i = (int)$options['offset'] + 1; $i < (int)$options['offset'] + 7; $i ++) {
+				$to = preg_replace_callback(
+					'/\$X/',
+					function ($m) use ($i) {
+						return '$' . $i;
+					},
+					$to,
+					1
+				);
+			}
+		}
+
+		// Convert any custom constraints to the CI/pattern equivalent
+		foreach ($this->constraints as $name => $pattern) {
+			$from = str_replace('{' . $name . '}', $pattern, $from);
+		}
+
+		$this->routes[$from] = $to;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Compares the subdomain(s) passed in against the current subdomain
+	 * on this page request.
+	 *
+	 * @param $subdomains
+	 * @return bool
+	 */
+	private function checkSubdomains($subdomains)
+	{
+		if (is_null($this->current_subdomain)) {
+			$this->determineCurrentSubdomain();
+		}
+
+		if (!is_array($subdomains)) {
+			$subdomains = array($subdomains);
+		}
+
+		$matched = false;
+
+		array_walk(
+			$subdomains,
+			function ($subdomain) use (&$matched) {
+				if ($subdomain == $this->current_subdomain || $subdomain == '*') {
+					$matched = true;
+				}
+			}
+		);
+
+		return $matched;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Examines the HTTP_HOST to get a best match for the subdomain. It
+	 * won't be perfect, but should work for our needs.
+	 */
+	private function determineCurrentSubdomain()
+	{
+		$parsedUrl = parse_url($_SERVER['HTTP_HOST']);
+
+		$host = explode('.', $parsedUrl['host']);
+
+		// If we only have 2 parts, then we don't have a subdomain.
+		// This won't be totally accurate, since URL's like example.co.uk
+		// would still pass, but it helps to separate the chaff...
+		if (!is_array($host) || count($host) == 2) {
+			// Set it to false so we don't make it back here again.
+			$this->current_subdomain = false;
+			return;
+		}
+
+		// Now, we'll simply take the first element of the array. This should
+		// be fine even in cases like example.co.uk, since they won't be looking
+		// for 'example' when they try to match the subdomain, in most all cases.
+		$this->current_subdomain = array_shift($host);
+	}
+	//--------------------------------------------------------------------
 
 }

application/helpers/markdown_extended_helper.php

Indentation +140 added lines, -140 removed lines

@@ -1,98 +1,98 @@ 
 <?php
 
 if (! function_exists('Markdown')) {
-    require_once('markdown_helper.php');
+	require_once('markdown_helper.php');
 }
 define('MARKDOWNEXTRAEXTENDED_VERSION', "0.3");
 
 function MarkdownExtended($text, $default_classes = array())
 {
-    $parser = new MarkdownExtraExtended_Parser($default_classes);
-    return $parser->transform($text);
+	$parser = new MarkdownExtraExtended_Parser($default_classes);
+	return $parser->transform($text);
 }
 
 class MarkdownExtraExtended_Parser extends MarkdownExtra_Parser
 {
 
-    # Tags that are always treated as block tags:
-    var $block_tags_re = 'figure|figcaption|p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|address|form|fieldset|iframe|hr|legend';
-
-    var $default_classes;
-
-    function __construct($default_classes = array())
-    {
-        $default_classes = $default_classes;
-
-        $this->block_gamut += array(
-            "doFencedFigures" => 7,
-        );
-
-        parent::__construct();
-    }
-
-    function transform($text)
-    {
-        $text = parent::transform($text);
-        return $text;
-    }
-
-    function doHardBreaks($text)
-    {
-        # Do hard breaks:
-        # EXTENDED: changed to allow breaks without two spaces and just one new line
-        # original code /* return preg_replace_callback('/ {2,}\n/', */
-        return preg_replace_callback(
-            '/ *\n/',
-            array(&$this, '_doHardBreaks_callback'),
-            $text
-        );
-    }
-
-    function doBlockQuotes($text)
-    {
-        $text = preg_replace_callback(
-            '/
+	# Tags that are always treated as block tags:
+	var $block_tags_re = 'figure|figcaption|p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|address|form|fieldset|iframe|hr|legend';
+
+	var $default_classes;
+
+	function __construct($default_classes = array())
+	{
+		$default_classes = $default_classes;
+
+		$this->block_gamut += array(
+			"doFencedFigures" => 7,
+		);
+
+		parent::__construct();
+	}
+
+	function transform($text)
+	{
+		$text = parent::transform($text);
+		return $text;
+	}
+
+	function doHardBreaks($text)
+	{
+		# Do hard breaks:
+		# EXTENDED: changed to allow breaks without two spaces and just one new line
+		# original code /* return preg_replace_callback('/ {2,}\n/', */
+		return preg_replace_callback(
+			'/ *\n/',
+			array(&$this, '_doHardBreaks_callback'),
+			$text
+		);
+	}
+
+	function doBlockQuotes($text)
+	{
+		$text = preg_replace_callback(
+			'/
 			(?>^[ ]*>[ ]?
 				(?:\((.+?)\))?
 				[ ]*(.+\n(?:.+\n)*)
 			)+
 			/xm',
-            array(&$this, '_doBlockQuotes_callback'),
-            $text
-        );
-
-        return $text;
-    }
-
-    function _doBlockQuotes_callback($matches)
-    {
-        $cite = $matches[1];
-        $bq   = '> ' . $matches[2];
-        # trim one level of quoting - trim whitespace-only lines
-        $bq = preg_replace('/^[ ]*>[ ]?|^[ ]+$/m', '', $bq);
-        $bq = $this->runBlockGamut($bq); # recurse
-
-        $bq = preg_replace('/^/m', "  ", $bq);
-        # These leading spaces cause problem with <pre> content,
-        # so we need to fix that:
-        $bq = preg_replace_callback(
-            '{(\s*<pre>.+?</pre>)}sx',
-            array(&$this, '_doBlockQuotes_callback2'),
-            $bq
-        );
-
-        $res = "<blockquote";
-        $res .= empty($cite) ? ">" : " cite=\"$cite\">";
-        $res .= "\n$bq\n</blockquote>";
-        return "\n" . $this->hashBlock($res) . "\n\n";
-    }
-
-    function doFencedCodeBlocks($text)
-    {
-        $less_than_tab = $this->tab_width;
-
-        $text = preg_replace_callback(
-            '{
+			array(&$this, '_doBlockQuotes_callback'),
+			$text
+		);
+
+		return $text;
+	}
+
+	function _doBlockQuotes_callback($matches)
+	{
+		$cite = $matches[1];
+		$bq   = '> ' . $matches[2];
+		# trim one level of quoting - trim whitespace-only lines
+		$bq = preg_replace('/^[ ]*>[ ]?|^[ ]+$/m', '', $bq);
+		$bq = $this->runBlockGamut($bq); # recurse
+
+		$bq = preg_replace('/^/m', "  ", $bq);
+		# These leading spaces cause problem with <pre> content,
+		# so we need to fix that:
+		$bq = preg_replace_callback(
+			'{(\s*<pre>.+?</pre>)}sx',
+			array(&$this, '_doBlockQuotes_callback2'),
+			$bq
+		);
+
+		$res = "<blockquote";
+		$res .= empty($cite) ? ">" : " cite=\"$cite\">";
+		$res .= "\n$bq\n</blockquote>";
+		return "\n" . $this->hashBlock($res) . "\n\n";
+	}
+
+	function doFencedCodeBlocks($text)
+	{
+		$less_than_tab = $this->tab_width;
+
+		$text = preg_replace_callback(
+			'{
 				(?:\n|\A)
 				# 1: Opening marker
 				(
@@ -112,34 +112,34 @@ 
 				# Closing marker.
 				\1 [ ]* \n
 			}xm',
-            array(&$this, '_doFencedCodeBlocks_callback'),
-            $text
-        );
-
-        return $text;
-    }
-
-    function _doFencedCodeBlocks_callback($matches)
-    {
-        $codeblock = $matches[4];
-        $codeblock = htmlspecialchars($codeblock, ENT_NOQUOTES);
-        $codeblock = preg_replace_callback(
-            '/^\n+/',
-            array(&$this, '_doFencedCodeBlocks_newlines'),
-            $codeblock
-        );
-        //$codeblock = "<pre><code>$codeblock</code></pre>";
-        //$cb = "<pre><code";
-        $cb = empty($matches[3]) ? "<pre><code" : "<pre class=\"linenums:$matches[3]\"><code";
-        $cb .= empty($matches[2]) ? ">" : " class=\"language-$matches[2]\">";
-        $cb .= "$codeblock</code></pre>";
-        return "\n\n" . $this->hashBlock($cb) . "\n\n";
-    }
-
-    function doFencedFigures($text)
-    {
-        $text = preg_replace_callback(
-            '{
+			array(&$this, '_doFencedCodeBlocks_callback'),
+			$text
+		);
+
+		return $text;
+	}
+
+	function _doFencedCodeBlocks_callback($matches)
+	{
+		$codeblock = $matches[4];
+		$codeblock = htmlspecialchars($codeblock, ENT_NOQUOTES);
+		$codeblock = preg_replace_callback(
+			'/^\n+/',
+			array(&$this, '_doFencedCodeBlocks_newlines'),
+			$codeblock
+		);
+		//$codeblock = "<pre><code>$codeblock</code></pre>";
+		//$cb = "<pre><code";
+		$cb = empty($matches[3]) ? "<pre><code" : "<pre class=\"linenums:$matches[3]\"><code";
+		$cb .= empty($matches[2]) ? ">" : " class=\"language-$matches[2]\">";
+		$cb .= "$codeblock</code></pre>";
+		return "\n\n" . $this->hashBlock($cb) . "\n\n";
+	}
+
+	function doFencedFigures($text)
+	{
+		$text = preg_replace_callback(
+			'{
 			(?:\n|\A)
 			# 1: Opening marker
 			(
@@ -159,41 +159,41 @@ 
 			# Closing marker.
 			\1 [ ]?(?:\[([^\]]+)\])?[ ]* \n
 		}xm',
-            array(&$this, '_doFencedFigures_callback'),
-            $text
-        );
-
-        return $text;
-    }
-
-    function _doFencedFigures_callback($matches)
-    {
-        # get figcaption
-        $topcaption    = empty($matches[2]) ? null : $this->runBlockGamut($matches[2]);
-        $bottomcaption = empty($matches[5]) ? null : $this->runBlockGamut($matches[5]);
-        $figure        = $matches[3];
-        $figure        = $this->runBlockGamut($figure); # recurse
-
-        $figure = preg_replace('/^/m', "  ", $figure);
-        # These leading spaces cause problem with <pre> content,
-        # so we need to fix that - reuse blockqoute code to handle this:
-        $figure = preg_replace_callback(
-            '{(\s*<pre>.+?</pre>)}sx',
-            array(&$this, '_doBlockQuotes_callback2'),
-            $figure
-        );
-
-        $res = "<figure>";
-        if (!empty($topcaption)) {
-            $res .= "\n<figcaption>$topcaption</figcaption>";
-        }
-        $res .= "\n$figure\n";
-        if (!empty($bottomcaption) && empty($topcaption)) {
-            $res .= "<figcaption>$bottomcaption</figcaption>";
-        }
-        $res .= "</figure>";
-        return "\n" . $this->hashBlock($res) . "\n\n";
-    }
+			array(&$this, '_doFencedFigures_callback'),
+			$text
+		);
+
+		return $text;
+	}
+
+	function _doFencedFigures_callback($matches)
+	{
+		# get figcaption
+		$topcaption    = empty($matches[2]) ? null : $this->runBlockGamut($matches[2]);
+		$bottomcaption = empty($matches[5]) ? null : $this->runBlockGamut($matches[5]);
+		$figure        = $matches[3];
+		$figure        = $this->runBlockGamut($figure); # recurse
+
+		$figure = preg_replace('/^/m', "  ", $figure);
+		# These leading spaces cause problem with <pre> content,
+		# so we need to fix that - reuse blockqoute code to handle this:
+		$figure = preg_replace_callback(
+			'{(\s*<pre>.+?</pre>)}sx',
+			array(&$this, '_doBlockQuotes_callback2'),
+			$figure
+		);
+
+		$res = "<figure>";
+		if (!empty($topcaption)) {
+			$res .= "\n<figcaption>$topcaption</figcaption>";
+		}
+		$res .= "\n$figure\n";
+		if (!empty($bottomcaption) && empty($topcaption)) {
+			$res .= "<figcaption>$bottomcaption</figcaption>";
+		}
+		$res .= "</figure>";
+		return "\n" . $this->hashBlock($res) . "\n\n";
+	}
 }
 
 ?>

application/helpers/markdown_helper.php

Indentation +2725 added lines, -2725 removed lines

@@ -56,15 +56,15 @@ 
 #
 # Initialize the parser and return the result of its transform method.
 #
-    # Setup static parser variable.
-    static $parser;
-    if (!isset($parser)) {
-        $parser_class = MARKDOWN_PARSER_CLASS;
-        $parser       = new $parser_class;
-    }
-
-    # Transform text using parser.
-    return $parser->transform($text);
+	# Setup static parser variable.
+	static $parser;
+	if (!isset($parser)) {
+		$parser_class = MARKDOWN_PARSER_CLASS;
+		$parser       = new $parser_class;
+	}
+
+	# Transform text using parser.
+	return $parser->transform($text);
 }
 
 ### WordPress Plugin Interface ###
@@ -80,120 +80,120 @@ 
 */
 
 if (isset($wp_version)) {
-    # More details about how it works here:
-    # <http://michelf.ca/weblog/2005/wordpress-text-flow-vs-markdown/>
-
-    # Post content and excerpts
-    # - Remove WordPress paragraph generator.
-    # - Run Markdown on excerpt, then remove all tags.
-    # - Add paragraph tag around the excerpt, but remove it for the excerpt rss.
-    if (MARKDOWN_WP_POSTS) {
-        remove_filter('the_content', 'wpautop');
-        remove_filter('the_content_rss', 'wpautop');
-        remove_filter('the_excerpt', 'wpautop');
-        add_filter('the_content', 'mdwp_MarkdownPost', 6);
-        add_filter('the_content_rss', 'mdwp_MarkdownPost', 6);
-        add_filter('get_the_excerpt', 'mdwp_MarkdownPost', 6);
-        add_filter('get_the_excerpt', 'trim', 7);
-        add_filter('the_excerpt', 'mdwp_add_p');
-        add_filter('the_excerpt_rss', 'mdwp_strip_p');
-
-        remove_filter('content_save_pre', 'balanceTags', 50);
-        remove_filter('excerpt_save_pre', 'balanceTags', 50);
-        add_filter('the_content', 'balanceTags', 50);
-        add_filter('get_the_excerpt', 'balanceTags', 9);
-    }
-
-    # Add a footnote id prefix to posts when inside a loop.
-    function mdwp_MarkdownPost($text)
-    {
-        static $parser;
-        if (!$parser) {
-            $parser_class = MARKDOWN_PARSER_CLASS;
-            $parser       = new $parser_class;
-        }
-        if (is_single() || is_page() || is_feed()) {
-            $parser->fn_id_prefix = "";
-        } else {
-            $parser->fn_id_prefix = get_the_ID() . ".";
-        }
-        return $parser->transform($text);
-    }
-
-    # Comments
-    # - Remove WordPress paragraph generator.
-    # - Remove WordPress auto-link generator.
-    # - Scramble important tags before passing them to the kses filter.
-    # - Run Markdown on excerpt then remove paragraph tags.
-    if (MARKDOWN_WP_COMMENTS) {
-        remove_filter('comment_text', 'wpautop', 30);
-        remove_filter('comment_text', 'make_clickable');
-        add_filter('pre_comment_content', 'Markdown', 6);
-        add_filter('pre_comment_content', 'mdwp_hide_tags', 8);
-        add_filter('pre_comment_content', 'mdwp_show_tags', 12);
-        add_filter('get_comment_text', 'Markdown', 6);
-        add_filter('get_comment_excerpt', 'Markdown', 6);
-        add_filter('get_comment_excerpt', 'mdwp_strip_p', 7);
-
-        global $mdwp_hidden_tags, $mdwp_placeholders;
-        $mdwp_hidden_tags  = explode(
-            ' ',
-            '<p> </p> <pre> </pre> <ol> </ol> <ul> </ul> <li> </li>'
-        );
-        $mdwp_placeholders = explode(
-            ' ',
-            str_rot13(
-                'pEj07ZbbBZ U1kqgh4w4p pre2zmeN6K QTi31t9pre ol0MP1jzJR ' .
-                'ML5IjmbRol ulANi1NsGY J7zRLJqPul liA8ctl16T K9nhooUHli'
-            )
-        );
-    }
-
-    function mdwp_add_p($text)
-    {
-        if (!preg_match('{^$|^<(p|ul|ol|dl|pre|blockquote)>}i', $text)) {
-            $text = '<p>' . $text . '</p>';
-            $text = preg_replace('{\n{2,}}', "</p>\n\n<p>", $text);
-        }
-        return $text;
-    }
-
-    function mdwp_strip_p($t) { return preg_replace('{</?p>}i', '', $t); }
-
-    function mdwp_hide_tags($text)
-    {
-        global $mdwp_hidden_tags, $mdwp_placeholders;
-        return str_replace($mdwp_hidden_tags, $mdwp_placeholders, $text);
-    }
-
-    function mdwp_show_tags($text)
-    {
-        global $mdwp_hidden_tags, $mdwp_placeholders;
-        return str_replace($mdwp_placeholders, $mdwp_hidden_tags, $text);
-    }
+	# More details about how it works here:
+	# <http://michelf.ca/weblog/2005/wordpress-text-flow-vs-markdown/>
+
+	# Post content and excerpts
+	# - Remove WordPress paragraph generator.
+	# - Run Markdown on excerpt, then remove all tags.
+	# - Add paragraph tag around the excerpt, but remove it for the excerpt rss.
+	if (MARKDOWN_WP_POSTS) {
+		remove_filter('the_content', 'wpautop');
+		remove_filter('the_content_rss', 'wpautop');
+		remove_filter('the_excerpt', 'wpautop');
+		add_filter('the_content', 'mdwp_MarkdownPost', 6);
+		add_filter('the_content_rss', 'mdwp_MarkdownPost', 6);
+		add_filter('get_the_excerpt', 'mdwp_MarkdownPost', 6);
+		add_filter('get_the_excerpt', 'trim', 7);
+		add_filter('the_excerpt', 'mdwp_add_p');
+		add_filter('the_excerpt_rss', 'mdwp_strip_p');
+
+		remove_filter('content_save_pre', 'balanceTags', 50);
+		remove_filter('excerpt_save_pre', 'balanceTags', 50);
+		add_filter('the_content', 'balanceTags', 50);
+		add_filter('get_the_excerpt', 'balanceTags', 9);
+	}
+
+	# Add a footnote id prefix to posts when inside a loop.
+	function mdwp_MarkdownPost($text)
+	{
+		static $parser;
+		if (!$parser) {
+			$parser_class = MARKDOWN_PARSER_CLASS;
+			$parser       = new $parser_class;
+		}
+		if (is_single() || is_page() || is_feed()) {
+			$parser->fn_id_prefix = "";
+		} else {
+			$parser->fn_id_prefix = get_the_ID() . ".";
+		}
+		return $parser->transform($text);
+	}
+
+	# Comments
+	# - Remove WordPress paragraph generator.
+	# - Remove WordPress auto-link generator.
+	# - Scramble important tags before passing them to the kses filter.
+	# - Run Markdown on excerpt then remove paragraph tags.
+	if (MARKDOWN_WP_COMMENTS) {
+		remove_filter('comment_text', 'wpautop', 30);
+		remove_filter('comment_text', 'make_clickable');
+		add_filter('pre_comment_content', 'Markdown', 6);
+		add_filter('pre_comment_content', 'mdwp_hide_tags', 8);
+		add_filter('pre_comment_content', 'mdwp_show_tags', 12);
+		add_filter('get_comment_text', 'Markdown', 6);
+		add_filter('get_comment_excerpt', 'Markdown', 6);
+		add_filter('get_comment_excerpt', 'mdwp_strip_p', 7);
+
+		global $mdwp_hidden_tags, $mdwp_placeholders;
+		$mdwp_hidden_tags  = explode(
+			' ',
+			'<p> </p> <pre> </pre> <ol> </ol> <ul> </ul> <li> </li>'
+		);
+		$mdwp_placeholders = explode(
+			' ',
+			str_rot13(
+				'pEj07ZbbBZ U1kqgh4w4p pre2zmeN6K QTi31t9pre ol0MP1jzJR ' .
+				'ML5IjmbRol ulANi1NsGY J7zRLJqPul liA8ctl16T K9nhooUHli'
+			)
+		);
+	}
+
+	function mdwp_add_p($text)
+	{
+		if (!preg_match('{^$|^<(p|ul|ol|dl|pre|blockquote)>}i', $text)) {
+			$text = '<p>' . $text . '</p>';
+			$text = preg_replace('{\n{2,}}', "</p>\n\n<p>", $text);
+		}
+		return $text;
+	}
+
+	function mdwp_strip_p($t) { return preg_replace('{</?p>}i', '', $t); }
+
+	function mdwp_hide_tags($text)
+	{
+		global $mdwp_hidden_tags, $mdwp_placeholders;
+		return str_replace($mdwp_hidden_tags, $mdwp_placeholders, $text);
+	}
+
+	function mdwp_show_tags($text)
+	{
+		global $mdwp_hidden_tags, $mdwp_placeholders;
+		return str_replace($mdwp_placeholders, $mdwp_hidden_tags, $text);
+	}
 }
 
 ### bBlog Plugin Info ###
 
 function identify_modifier_markdown()
 {
-    return array(
-        'name'        => 'markdown',
-        'type'        => 'modifier',
-        'nicename'    => 'PHP Markdown Extra',
-        'description' => 'A text-to-HTML conversion tool for web writers',
-        'authors'     => 'Michel Fortin and John Gruber',
-        'licence'     => 'GPL',
-        'version'     => MARKDOWNEXTRA_VERSION,
-        'help'        => '<a href="http://daringfireball.net/projects/markdown/syntax">Markdown syntax</a> allows you to write using an easy-to-read, easy-to-write plain text format. Based on the original Perl version by <a href="http://daringfireball.net/">John Gruber</a>. <a href="http://michelf.ca/projects/php-markdown/">More...</a>',
-    );
+	return array(
+		'name'        => 'markdown',
+		'type'        => 'modifier',
+		'nicename'    => 'PHP Markdown Extra',
+		'description' => 'A text-to-HTML conversion tool for web writers',
+		'authors'     => 'Michel Fortin and John Gruber',
+		'licence'     => 'GPL',
+		'version'     => MARKDOWNEXTRA_VERSION,
+		'help'        => '<a href="http://daringfireball.net/projects/markdown/syntax">Markdown syntax</a> allows you to write using an easy-to-read, easy-to-write plain text format. Based on the original Perl version by <a href="http://daringfireball.net/">John Gruber</a>. <a href="http://michelf.ca/projects/php-markdown/">More...</a>',
+	);
 }
 
 ### Smarty Modifier Interface ###
 
 function smarty_modifier_markdown($text)
 {
-    return Markdown($text);
+	return Markdown($text);
 }
 
 ### Textile Compatibility Mode ###
@@ -201,32 +201,32 @@ 
 # Rename this file to "classTextile.php" and it can replace Textile everywhere.
 
 if (strcasecmp(substr(__FILE__, - 16), "classTextile.php") == 0) {
-    # Try to include PHP SmartyPants. Should be in the same directory.
-    @include_once 'smartypants.php';
-
-    # Fake Textile class. It calls Markdown instead.
-    class Textile
-    {
-        function TextileThis($text, $lite = '', $encode = '')
-        {
-            if ($lite == '' && $encode == '') {
-                $text = Markdown($text);
-            }
-            if (function_exists('SmartyPants')) {
-                $text = SmartyPants($text);
-            }
-            return $text;
-        }
-
-        # Fake restricted version: restrictions are not supported for now.
-        function TextileRestricted($text, $lite = '', $noimage = '')
-        {
-            return $this->TextileThis($text, $lite);
-        }
-
-        # Workaround to ensure compatibility with TextPattern 4.0.3.
-        function blockLite($text) { return $text; }
-    }
+	# Try to include PHP SmartyPants. Should be in the same directory.
+	@include_once 'smartypants.php';
+
+	# Fake Textile class. It calls Markdown instead.
+	class Textile
+	{
+		function TextileThis($text, $lite = '', $encode = '')
+		{
+			if ($lite == '' && $encode == '') {
+				$text = Markdown($text);
+			}
+			if (function_exists('SmartyPants')) {
+				$text = SmartyPants($text);
+			}
+			return $text;
+		}
+
+		# Fake restricted version: restrictions are not supported for now.
+		function TextileRestricted($text, $lite = '', $noimage = '')
+		{
+			return $this->TextileThis($text, $lite);
+		}
+
+		# Workaround to ensure compatibility with TextPattern 4.0.3.
+		function blockLite($text) { return $text; }
+	}
 }
 
 #
@@ -236,156 +236,156 @@ 
 class Markdown_Parser
 {
 
-    ### Configuration Variables ###
+	### Configuration Variables ###
 
-    # Change to ">" for HTML output.
-    var $empty_element_suffix = MARKDOWN_EMPTY_ELEMENT_SUFFIX;
+	# Change to ">" for HTML output.
+	var $empty_element_suffix = MARKDOWN_EMPTY_ELEMENT_SUFFIX;
 
-    var $tab_width = MARKDOWN_TAB_WIDTH;
+	var $tab_width = MARKDOWN_TAB_WIDTH;
 
-    # Change to `true` to disallow markup or entities.
-    var $no_markup = false;
+	# Change to `true` to disallow markup or entities.
+	var $no_markup = false;
 
-    var $no_entities = false;
+	var $no_entities = false;
 
-    # Predefined urls and titles for reference links and images.
-    var $predef_urls = array();
+	# Predefined urls and titles for reference links and images.
+	var $predef_urls = array();
 
-    var $predef_titles = array();
+	var $predef_titles = array();
 
-    ### Parser Implementation ###
+	### Parser Implementation ###
 
-    # Regex to match balanced [brackets].
-    # Needed to insert a maximum bracked depth while converting to PHP.
-    var $nested_brackets_depth = 6;
+	# Regex to match balanced [brackets].
+	# Needed to insert a maximum bracked depth while converting to PHP.
+	var $nested_brackets_depth = 6;
 
-    var $nested_brackets_re;
+	var $nested_brackets_re;
 
-    var $nested_url_parenthesis_depth = 4;
+	var $nested_url_parenthesis_depth = 4;
 
-    var $nested_url_parenthesis_re;
+	var $nested_url_parenthesis_re;
 
-    # Table of hash values for escaped characters:
-    var $escape_chars = '\`*_{}[]()>#+-.!';
+	# Table of hash values for escaped characters:
+	var $escape_chars = '\`*_{}[]()>#+-.!';
 
-    var $escape_chars_re;
+	var $escape_chars_re;
 
-    function __construct()
-    {
-        #
-        # Constructor function. Initialize appropriate member variables.
-        #
-        $this->_initDetab();
-        $this->prepareItalicsAndBold();
+	function __construct()
+	{
+		#
+		# Constructor function. Initialize appropriate member variables.
+		#
+		$this->_initDetab();
+		$this->prepareItalicsAndBold();
 
-        $this->nested_brackets_re =
-            str_repeat('(?>[^\[\]]+|\[', $this->nested_brackets_depth) .
-            str_repeat('\])*', $this->nested_brackets_depth);
+		$this->nested_brackets_re =
+			str_repeat('(?>[^\[\]]+|\[', $this->nested_brackets_depth) .
+			str_repeat('\])*', $this->nested_brackets_depth);
 
-        $this->nested_url_parenthesis_re =
-            str_repeat('(?>[^()\s]+|\(', $this->nested_url_parenthesis_depth) .
-            str_repeat('(?>\)))*', $this->nested_url_parenthesis_depth);
+		$this->nested_url_parenthesis_re =
+			str_repeat('(?>[^()\s]+|\(', $this->nested_url_parenthesis_depth) .
+			str_repeat('(?>\)))*', $this->nested_url_parenthesis_depth);
 
-        $this->escape_chars_re = '[' . preg_quote($this->escape_chars) . ']';
+		$this->escape_chars_re = '[' . preg_quote($this->escape_chars) . ']';
 
-        # Sort document, block, and span gamut in ascendent priority order.
-        asort($this->document_gamut);
-        asort($this->block_gamut);
-        asort($this->span_gamut);
-    }
+		# Sort document, block, and span gamut in ascendent priority order.
+		asort($this->document_gamut);
+		asort($this->block_gamut);
+		asort($this->span_gamut);
+	}
 
-    # Internal hashes used during transformation.
-    var $urls = array();
+	# Internal hashes used during transformation.
+	var $urls = array();
 
-    var $titles = array();
+	var $titles = array();
 
-    var $html_hashes = array();
+	var $html_hashes = array();
 
-    # Status flag to avoid invalid nesting.
-    var $in_anchor = false;
+	# Status flag to avoid invalid nesting.
+	var $in_anchor = false;
 
-    function setup()
-    {
-        #
-        # Called before the transformation process starts to setup parser
-        # states.
-        #
-        # Clear global hashes.
-        $this->urls        = $this->predef_urls;
-        $this->titles      = $this->predef_titles;
-        $this->html_hashes = array();
+	function setup()
+	{
+		#
+		# Called before the transformation process starts to setup parser
+		# states.
+		#
+		# Clear global hashes.
+		$this->urls        = $this->predef_urls;
+		$this->titles      = $this->predef_titles;
+		$this->html_hashes = array();
 
-        $this->in_anchor = false;
-    }
+		$this->in_anchor = false;
+	}
 
-    function teardown()
-    {
-        #
-        # Called after the transformation process to clear any variable
-        # which may be taking up memory unnecessarly.
-        #
-        $this->urls        = array();
-        $this->titles      = array();
-        $this->html_hashes = array();
-    }
+	function teardown()
+	{
+		#
+		# Called after the transformation process to clear any variable
+		# which may be taking up memory unnecessarly.
+		#
+		$this->urls        = array();
+		$this->titles      = array();
+		$this->html_hashes = array();
+	}
 
-    function transform($text)
-    {
-        #
-        # Main function. Performs some preprocessing on the input text
-        # and pass it through the document gamut.
-        #
-        $this->setup();
+	function transform($text)
+	{
+		#
+		# Main function. Performs some preprocessing on the input text
+		# and pass it through the document gamut.
+		#
+		$this->setup();
 
-        # Remove UTF-8 BOM and marker character in input, if present.
-        $text = preg_replace('{^\xEF\xBB\xBF|\x1A}', '', $text);
+		# Remove UTF-8 BOM and marker character in input, if present.
+		$text = preg_replace('{^\xEF\xBB\xBF|\x1A}', '', $text);
 
-        # Standardize line endings:
-        #   DOS to Unix and Mac to Unix
-        $text = preg_replace('{\r\n?}', "\n", $text);
+		# Standardize line endings:
+		#   DOS to Unix and Mac to Unix
+		$text = preg_replace('{\r\n?}', "\n", $text);
 
-        # Make sure $text ends with a couple of newlines:
-        $text .= "\n\n";
-
-        # Convert all tabs to spaces.
-        $text = $this->detab($text);
-
-        # Turn block-level HTML blocks into hash entries
-        $text = $this->hashHTMLBlocks($text);
-
-        # Strip any lines consisting only of spaces and tabs.
-        # This makes subsequent regexen easier to write, because we can
-        # match consecutive blank lines with /\n+/ instead of something
-        # contorted like /[ ]*\n+/ .
-        $text = preg_replace('/^[ ]+$/m', '', $text);
-
-        # Run document gamut methods.
-        foreach ($this->document_gamut as $method => $priority) {
-            $text = $this->$method($text);
-        }
-
-        $this->teardown();
-
-        return $text . "\n";
-    }
-
-    var $document_gamut = array(
-        # Strip link definitions, store in hashes.
-        "stripLinkDefinitions" => 20,
-        "runBasicBlockGamut"   => 30,
-    );
-
-    function stripLinkDefinitions($text)
-    {
-        #
-        # Strips link definitions from text, stores the URLs and titles in
-        # hash references.
-        #
-        $less_than_tab = $this->tab_width - 1;
-
-        # Link defs are in the form: ^[id]: url "optional title"
-        $text = preg_replace_callback(
-            '{
+		# Make sure $text ends with a couple of newlines:
+		$text .= "\n\n";
+
+		# Convert all tabs to spaces.
+		$text = $this->detab($text);
+
+		# Turn block-level HTML blocks into hash entries
+		$text = $this->hashHTMLBlocks($text);
+
+		# Strip any lines consisting only of spaces and tabs.
+		# This makes subsequent regexen easier to write, because we can
+		# match consecutive blank lines with /\n+/ instead of something
+		# contorted like /[ ]*\n+/ .
+		$text = preg_replace('/^[ ]+$/m', '', $text);
+
+		# Run document gamut methods.
+		foreach ($this->document_gamut as $method => $priority) {
+			$text = $this->$method($text);
+		}
+
+		$this->teardown();
+
+		return $text . "\n";
+	}
+
+	var $document_gamut = array(
+		# Strip link definitions, store in hashes.
+		"stripLinkDefinitions" => 20,
+		"runBasicBlockGamut"   => 30,
+	);
+
+	function stripLinkDefinitions($text)
+	{
+		#
+		# Strips link definitions from text, stores the URLs and titles in
+		# hash references.
+		#
+		$less_than_tab = $this->tab_width - 1;
+
+		# Link defs are in the form: ^[id]: url "optional title"
+		$text = preg_replace_callback(
+			'{
 							^[ ]{0,' . $less_than_tab . '}\[(.+)\][ ]?:	# id = $1
 							  [ ]*
 							  \n?				# maybe *one* newline
@@ -407,51 +407,51 @@ 
 							)?	# title is optional
 							(?:\n+|\Z)
 			}xm',
-            array(&$this, '_stripLinkDefinitions_callback'),
-            $text
-        );
-        return $text;
-    }
-
-    function _stripLinkDefinitions_callback($matches)
-    {
-        $link_id                = strtolower($matches[1]);
-        $url                    = $matches[2] == '' ? $matches[3] : $matches[2];
-        $this->urls[$link_id]   = $url;
-        $this->titles[$link_id] =& $matches[4];
-        return ''; # String that will replace the block
-    }
-
-    function hashHTMLBlocks($text)
-    {
-        if ($this->no_markup) {
-            return $text;
-        }
-
-        $less_than_tab = $this->tab_width - 1;
-
-        # Hashify HTML blocks:
-        # We only want to do this for block-level HTML tags, such as headers,
-        # lists, and tables. That's because we still want to wrap <p>s around
-        # "paragraphs" that are wrapped in non-block-level tags, such as anchors,
-        # phrase emphasis, and spans. The list of tags we're looking for is
-        # hard-coded:
-        #
-        # *  List "a" is made of tags which can be both inline or block-level.
-        #    These will be treated block-level when the start tag is alone on
-        #    its line, otherwise they're not matched here and will be taken as
-        #    inline later.
-        # *  List "b" is made of tags which are always block-level;
-        #
-        $block_tags_a_re = 'ins|del';
-        $block_tags_b_re = 'p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|address|' .
-                           'script|noscript|form|fieldset|iframe|math|svg|' .
-                           'article|section|nav|aside|hgroup|header|footer|' .
-                           'figure';
-
-        # Regular expression for the content of a block tag.
-        $nested_tags_level = 4;
-        $attr              = '
+			array(&$this, '_stripLinkDefinitions_callback'),
+			$text
+		);
+		return $text;
+	}
+
+	function _stripLinkDefinitions_callback($matches)
+	{
+		$link_id                = strtolower($matches[1]);
+		$url                    = $matches[2] == '' ? $matches[3] : $matches[2];
+		$this->urls[$link_id]   = $url;
+		$this->titles[$link_id] =& $matches[4];
+		return ''; # String that will replace the block
+	}
+
+	function hashHTMLBlocks($text)
+	{
+		if ($this->no_markup) {
+			return $text;
+		}
+
+		$less_than_tab = $this->tab_width - 1;
+
+		# Hashify HTML blocks:
+		# We only want to do this for block-level HTML tags, such as headers,
+		# lists, and tables. That's because we still want to wrap <p>s around
+		# "paragraphs" that are wrapped in non-block-level tags, such as anchors,
+		# phrase emphasis, and spans. The list of tags we're looking for is
+		# hard-coded:
+		#
+		# *  List "a" is made of tags which can be both inline or block-level.
+		#    These will be treated block-level when the start tag is alone on
+		#    its line, otherwise they're not matched here and will be taken as
+		#    inline later.
+		# *  List "b" is made of tags which are always block-level;
+		#
+		$block_tags_a_re = 'ins|del';
+		$block_tags_b_re = 'p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|address|' .
+						   'script|noscript|form|fieldset|iframe|math|svg|' .
+						   'article|section|nav|aside|hgroup|header|footer|' .
+						   'figure';
+
+		# Regular expression for the content of a block tag.
+		$nested_tags_level = 4;
+		$attr              = '
 			(?>				# optional tag attributes
 			  \s			# starts with whitespace
 			  (?>
@@ -465,9 +465,9 @@ 
 			  )*
 			)?
 			';
-        $content           =
-            str_repeat(
-                '
+		$content           =
+			str_repeat(
+				'
 				(?>
 				  [^<]+			# content without tag
 				|
@@ -477,34 +477,34 @@ 
 					  />
 					|
 					  >',
-                $nested_tags_level
-            ) . # end of opening tag
-            '.*?' . # last level nested tag content
-            str_repeat(
-                '
+				$nested_tags_level
+			) . # end of opening tag
+			'.*?' . # last level nested tag content
+			str_repeat(
+				'
 					  </\2\s*>	# closing nested tag
 					)
 				  |
 					<(?!/\2\s*>	# other tags with a different name
 				  )
 				)*',
-                $nested_tags_level
-            );
-        $content2          = str_replace('\2', '\3', $content);
-
-        # First, look for nested blocks, e.g.:
-        # 	<div>
-        # 		<div>
-        # 		tags for inner block must be indented.
-        # 		</div>
-        # 	</div>
-        #
-        # The outermost tags must start at the left margin for this to match, and
-        # the inner nested divs must be indented.
-        # We need to do this before the next, more liberal match, because the next
-        # match will start at the first `<div>` and stop at the first `</div>`.
-        $text = preg_replace_callback(
-            '{(?>
+				$nested_tags_level
+			);
+		$content2          = str_replace('\2', '\3', $content);
+
+		# First, look for nested blocks, e.g.:
+		# 	<div>
+		# 		<div>
+		# 		tags for inner block must be indented.
+		# 		</div>
+		# 	</div>
+		#
+		# The outermost tags must start at the left margin for this to match, and
+		# the inner nested divs must be indented.
+		# We need to do this before the next, more liberal match, because the next
+		# match will start at the first `<div>` and stop at the first `</div>`.
+		$text = preg_replace_callback(
+			'{(?>
 			(?>
 				(?<=\n\n)		# Starting after a blank line
 				|				# or
@@ -565,100 +565,100 @@ 
 
 			)
 			)}Sxmi',
-            array(&$this, '_hashHTMLBlocks_callback'),
-            $text
-        );
-
-        return $text;
-    }
-
-    function _hashHTMLBlocks_callback($matches)
-    {
-        $text = $matches[1];
-        $key  = $this->hashBlock($text);
-        return "\n\n$key\n\n";
-    }
-
-    function hashPart($text, $boundary = 'X')
-    {
-        #
-        # Called whenever a tag must be hashed when a function insert an atomic
-        # element in the text stream. Passing $text to through this function gives
-        # a unique text-token which will be reverted back when calling unhash.
-        #
-        # The $boundary argument specify what character should be used to surround
-        # the token. By convension, "B" is used for block elements that needs not
-        # to be wrapped into paragraph tags at the end, ":" is used for elements
-        # that are word separators and "X" is used in the general case.
-        #
-        # Swap back any tag hash found in $text so we do not have to `unhash`
-        # multiple times at the end.
-        $text = $this->unhash($text);
-
-        # Then hash the block.
-        static $i = 0;
-        $key                     = "$boundary\x1A" . ++ $i . $boundary;
-        $this->html_hashes[$key] = $text;
-        return $key; # String that will replace the tag.
-    }
-
-    function hashBlock($text)
-    {
-        #
-        # Shortcut function for hashPart with block-level boundaries.
-        #
-        return $this->hashPart($text, 'B');
-    }
-
-    var $block_gamut = array(
-        #
-        # These are all the transformations that form block-level
-        # tags like paragraphs, headers, and list items.
-        #
-        "doHeaders"         => 10,
-        "doHorizontalRules" => 20,
-        "doLists"           => 40,
-        "doCodeBlocks"      => 50,
-        "doBlockQuotes"     => 60,
-    );
-
-    function runBlockGamut($text)
-    {
-        #
-        # Run block gamut tranformations.
-        #
-        # We need to escape raw HTML in Markdown source before doing anything
-        # else. This need to be done for each block, and not only at the
-        # begining in the Markdown function since hashed blocks can be part of
-        # list items and could have been indented. Indented blocks would have
-        # been seen as a code block in a previous pass of hashHTMLBlocks.
-        $text = $this->hashHTMLBlocks($text);
-
-        return $this->runBasicBlockGamut($text);
-    }
-
-    function runBasicBlockGamut($text)
-    {
-        #
-        # Run block gamut tranformations, without hashing HTML blocks. This is
-        # useful when HTML blocks are known to be already hashed, like in the first
-        # whole-document pass.
-        #
-        foreach ($this->block_gamut as $method => $priority) {
-            $text = $this->$method($text);
-        }
-
-        # Finally form paragraph and restore hashed blocks.
-        $text = $this->formParagraphs($text);
-
-        return $text;
-    }
-
-    function doHorizontalRules($text)
-    {
-        # Do Horizontal Rules:
-        return preg_replace(
-            '{
+			array(&$this, '_hashHTMLBlocks_callback'),
+			$text
+		);
+
+		return $text;
+	}
+
+	function _hashHTMLBlocks_callback($matches)
+	{
+		$text = $matches[1];
+		$key  = $this->hashBlock($text);
+		return "\n\n$key\n\n";
+	}
+
+	function hashPart($text, $boundary = 'X')
+	{
+		#
+		# Called whenever a tag must be hashed when a function insert an atomic
+		# element in the text stream. Passing $text to through this function gives
+		# a unique text-token which will be reverted back when calling unhash.
+		#
+		# The $boundary argument specify what character should be used to surround
+		# the token. By convension, "B" is used for block elements that needs not
+		# to be wrapped into paragraph tags at the end, ":" is used for elements
+		# that are word separators and "X" is used in the general case.
+		#
+		# Swap back any tag hash found in $text so we do not have to `unhash`
+		# multiple times at the end.
+		$text = $this->unhash($text);
+
+		# Then hash the block.
+		static $i = 0;
+		$key                     = "$boundary\x1A" . ++ $i . $boundary;
+		$this->html_hashes[$key] = $text;
+		return $key; # String that will replace the tag.
+	}
+
+	function hashBlock($text)
+	{
+		#
+		# Shortcut function for hashPart with block-level boundaries.
+		#
+		return $this->hashPart($text, 'B');
+	}
+
+	var $block_gamut = array(
+		#
+		# These are all the transformations that form block-level
+		# tags like paragraphs, headers, and list items.
+		#
+		"doHeaders"         => 10,
+		"doHorizontalRules" => 20,
+		"doLists"           => 40,
+		"doCodeBlocks"      => 50,
+		"doBlockQuotes"     => 60,
+	);
+
+	function runBlockGamut($text)
+	{
+		#
+		# Run block gamut tranformations.
+		#
+		# We need to escape raw HTML in Markdown source before doing anything
+		# else. This need to be done for each block, and not only at the
+		# begining in the Markdown function since hashed blocks can be part of
+		# list items and could have been indented. Indented blocks would have
+		# been seen as a code block in a previous pass of hashHTMLBlocks.
+		$text = $this->hashHTMLBlocks($text);
+
+		return $this->runBasicBlockGamut($text);
+	}
+
+	function runBasicBlockGamut($text)
+	{
+		#
+		# Run block gamut tranformations, without hashing HTML blocks. This is
+		# useful when HTML blocks are known to be already hashed, like in the first
+		# whole-document pass.
+		#
+		foreach ($this->block_gamut as $method => $priority) {
+			$text = $this->$method($text);
+		}
+
+		# Finally form paragraph and restore hashed blocks.
+		$text = $this->formParagraphs($text);
+
+		return $text;
+	}
+
+	function doHorizontalRules($text)
+	{
+		# Do Horizontal Rules:
+		return preg_replace(
+			'{
 				^[ ]{0,3}	# Leading space
 				([-*_])		# $1: First marker
 				(?>			# Repeated marker group
@@ -668,74 +668,74 @@ 
 				[ ]*		# Tailing spaces
 				$			# End of line.
 			}mx',
-            "\n" . $this->hashBlock("<hr$this->empty_element_suffix") . "\n",
-            $text
-        );
-    }
-
-    var $span_gamut = array(
-        #
-        # These are all the transformations that occur *within* block-level
-        # tags like paragraphs, headers, and list items.
-        #
-        # Process character escapes, code spans, and inline HTML
-        # in one shot.
-        "parseSpan"           => - 30,
-        # Process anchor and image tags. Images must come first,
-        # because ![foo][f] looks like an anchor.
-        "doImages"            => 10,
-        "doAnchors"           => 20,
-        # Make links out of things like `<http://example.com/>`
-        # Must come after doAnchors, because you can use < and >
-        # delimiters in inline links like [this](<url>).
-        "doAutoLinks"         => 30,
-        "encodeAmpsAndAngles" => 40,
-        "doItalicsAndBold"    => 50,
-        "doHardBreaks"        => 60,
-    );
-
-    function runSpanGamut($text)
-    {
-        #
-        # Run span gamut tranformations.
-        #
-        foreach ($this->span_gamut as $method => $priority) {
-            $text = $this->$method($text);
-        }
-
-        return $text;
-    }
-
-    function doHardBreaks($text)
-    {
-        # Do hard breaks:
-        return preg_replace_callback(
-            '/ {2,}\n/',
-            array(&$this, '_doHardBreaks_callback'),
-            $text
-        );
-    }
-
-    function _doHardBreaks_callback($matches)
-    {
-        return $this->hashPart("<br$this->empty_element_suffix\n");
-    }
-
-    function doAnchors($text)
-    {
-        #
-        # Turn Markdown link shortcuts into XHTML <a> tags.
-        #
-        if ($this->in_anchor) {
-            return $text;
-        }
-        $this->in_anchor = true;
-
-        #
-        # First, handle reference-style links: [link text] [id]
-        #
-        $text = preg_replace_callback(
-            '{
+			"\n" . $this->hashBlock("<hr$this->empty_element_suffix") . "\n",
+			$text
+		);
+	}
+
+	var $span_gamut = array(
+		#
+		# These are all the transformations that occur *within* block-level
+		# tags like paragraphs, headers, and list items.
+		#
+		# Process character escapes, code spans, and inline HTML
+		# in one shot.
+		"parseSpan"           => - 30,
+		# Process anchor and image tags. Images must come first,
+		# because ![foo][f] looks like an anchor.
+		"doImages"            => 10,
+		"doAnchors"           => 20,
+		# Make links out of things like `<http://example.com/>`
+		# Must come after doAnchors, because you can use < and >
+		# delimiters in inline links like [this](<url>).
+		"doAutoLinks"         => 30,
+		"encodeAmpsAndAngles" => 40,
+		"doItalicsAndBold"    => 50,
+		"doHardBreaks"        => 60,
+	);
+
+	function runSpanGamut($text)
+	{
+		#
+		# Run span gamut tranformations.
+		#
+		foreach ($this->span_gamut as $method => $priority) {
+			$text = $this->$method($text);
+		}
+
+		return $text;
+	}
+
+	function doHardBreaks($text)
+	{
+		# Do hard breaks:
+		return preg_replace_callback(
+			'/ {2,}\n/',
+			array(&$this, '_doHardBreaks_callback'),
+			$text
+		);
+	}
+
+	function _doHardBreaks_callback($matches)
+	{
+		return $this->hashPart("<br$this->empty_element_suffix\n");
+	}
+
+	function doAnchors($text)
+	{
+		#
+		# Turn Markdown link shortcuts into XHTML <a> tags.
+		#
+		if ($this->in_anchor) {
+			return $text;
+		}
+		$this->in_anchor = true;
+
+		#
+		# First, handle reference-style links: [link text] [id]
+		#
+		$text = preg_replace_callback(
+			'{
 			(					# wrap whole match in $1
 			  \[
 				(' . $this->nested_brackets_re . ')	# link text = $2
@@ -749,15 +749,15 @@ 
 			  \]
 			)
 			}xs',
-            array(&$this, '_doAnchors_reference_callback'),
-            $text
-        );
-
-        #
-        # Next, inline-style links: [link text](url "optional title")
-        #
-        $text = preg_replace_callback(
-            '{
+			array(&$this, '_doAnchors_reference_callback'),
+			$text
+		);
+
+		#
+		# Next, inline-style links: [link text](url "optional title")
+		#
+		$text = preg_replace_callback(
+			'{
 			(				# wrap whole match in $1
 			  \[
 				(' . $this->nested_brackets_re . ')	# link text = $2
@@ -779,97 +779,97 @@ 
 			  \)
 			)
 			}xs',
-            array(&$this, '_doAnchors_inline_callback'),
-            $text
-        );
-
-        #
-        # Last, handle reference-style shortcuts: [link text]
-        # These must come last in case you've also got [link text][1]
-        # or [link text](/foo)
-        #
-        $text = preg_replace_callback(
-            '{
+			array(&$this, '_doAnchors_inline_callback'),
+			$text
+		);
+
+		#
+		# Last, handle reference-style shortcuts: [link text]
+		# These must come last in case you've also got [link text][1]
+		# or [link text](/foo)
+		#
+		$text = preg_replace_callback(
+			'{
 			(					# wrap whole match in $1
 			  \[
 				([^\[\]]+)		# link text = $2; can\'t contain [ or ]
 			  \]
 			)
 			}xs',
-            array(&$this, '_doAnchors_reference_callback'),
-            $text
-        );
-
-        $this->in_anchor = false;
-        return $text;
-    }
-
-    function _doAnchors_reference_callback($matches)
-    {
-        $whole_match = $matches[1];
-        $link_text   = $matches[2];
-        $link_id     =& $matches[3];
-
-        if ($link_id == "") {
-            # for shortcut links like [this][] or [this].
-            $link_id = $link_text;
-        }
-
-        # lower-case and turn embedded newlines into spaces
-        $link_id = strtolower($link_id);
-        $link_id = preg_replace('{[ ]?\n}', ' ', $link_id);
-
-        if (isset($this->urls[$link_id])) {
-            $url = $this->urls[$link_id];
-            $url = $this->encodeAttribute($url);
-
-            $result = "<a href=\"$url\"";
-            if (isset($this->titles[$link_id])) {
-                $title = $this->titles[$link_id];
-                $title = $this->encodeAttribute($title);
-                $result .= " title=\"$title\"";
-            }
-
-            $link_text = $this->runSpanGamut($link_text);
-            $result .= ">$link_text</a>";
-            $result = $this->hashPart($result);
-        } else {
-            $result = $whole_match;
-        }
-        return $result;
-    }
-
-    function _doAnchors_inline_callback($matches)
-    {
-        $whole_match = $matches[1];
-        $link_text   = $this->runSpanGamut($matches[2]);
-        $url         = $matches[3] == '' ? $matches[4] : $matches[3];
-        $title       =& $matches[7];
-
-        $url = $this->encodeAttribute($url);
-
-        $result = "<a href=\"$url\"";
-        if (isset($title)) {
-            $title = $this->encodeAttribute($title);
-            $result .= " title=\"$title\"";
-        }
-
-        $link_text = $this->runSpanGamut($link_text);
-        $result .= ">$link_text</a>";
-
-        return $this->hashPart($result);
-    }
-
-    function doImages($text)
-    {
-        #
-        # Turn Markdown image shortcuts into <img> tags.
-        #
-        #
-        # First, handle reference-style labeled images: ![alt text][id]
-        #
-        $text = preg_replace_callback(
-            '{
+			array(&$this, '_doAnchors_reference_callback'),
+			$text
+		);
+
+		$this->in_anchor = false;
+		return $text;
+	}
+
+	function _doAnchors_reference_callback($matches)
+	{
+		$whole_match = $matches[1];
+		$link_text   = $matches[2];
+		$link_id     =& $matches[3];
+
+		if ($link_id == "") {
+			# for shortcut links like [this][] or [this].
+			$link_id = $link_text;
+		}
+
+		# lower-case and turn embedded newlines into spaces
+		$link_id = strtolower($link_id);
+		$link_id = preg_replace('{[ ]?\n}', ' ', $link_id);
+
+		if (isset($this->urls[$link_id])) {
+			$url = $this->urls[$link_id];
+			$url = $this->encodeAttribute($url);
+
+			$result = "<a href=\"$url\"";
+			if (isset($this->titles[$link_id])) {
+				$title = $this->titles[$link_id];
+				$title = $this->encodeAttribute($title);
+				$result .= " title=\"$title\"";
+			}
+
+			$link_text = $this->runSpanGamut($link_text);
+			$result .= ">$link_text</a>";
+			$result = $this->hashPart($result);
+		} else {
+			$result = $whole_match;
+		}
+		return $result;
+	}
+
+	function _doAnchors_inline_callback($matches)
+	{
+		$whole_match = $matches[1];
+		$link_text   = $this->runSpanGamut($matches[2]);
+		$url         = $matches[3] == '' ? $matches[4] : $matches[3];
+		$title       =& $matches[7];
+
+		$url = $this->encodeAttribute($url);
+
+		$result = "<a href=\"$url\"";
+		if (isset($title)) {
+			$title = $this->encodeAttribute($title);
+			$result .= " title=\"$title\"";
+		}
+
+		$link_text = $this->runSpanGamut($link_text);
+		$result .= ">$link_text</a>";
+
+		return $this->hashPart($result);
+	}
+
+	function doImages($text)
+	{
+		#
+		# Turn Markdown image shortcuts into <img> tags.
+		#
+		#
+		# First, handle reference-style labeled images: ![alt text][id]
+		#
+		$text = preg_replace_callback(
+			'{
 			(				# wrap whole match in $1
 			  !\[
 				(' . $this->nested_brackets_re . ')		# alt text = $2
@@ -884,16 +884,16 @@ 
 
 			)
 			}xs',
-            array(&$this, '_doImages_reference_callback'),
-            $text
-        );
-
-        #
-        # Next, handle inline images:  ![alt text](url "optional title")
-        # Don't forget: encode * and _
-        #
-        $text = preg_replace_callback(
-            '{
+			array(&$this, '_doImages_reference_callback'),
+			$text
+		);
+
+		#
+		# Next, handle inline images:  ![alt text](url "optional title")
+		# Don't forget: encode * and _
+		#
+		$text = preg_replace_callback(
+			'{
 			(				# wrap whole match in $1
 			  !\[
 				(' . $this->nested_brackets_re . ')		# alt text = $2
@@ -916,85 +916,85 @@ 
 			  \)
 			)
 			}xs',
-            array(&$this, '_doImages_inline_callback'),
-            $text
-        );
-
-        return $text;
-    }
-
-    function _doImages_reference_callback($matches)
-    {
-        $whole_match = $matches[1];
-        $alt_text    = $matches[2];
-        $link_id     = strtolower($matches[3]);
-
-        if ($link_id == "") {
-            $link_id = strtolower($alt_text); # for shortcut links like ![this][].
-        }
-
-        $alt_text = $this->encodeAttribute($alt_text);
-        if (isset($this->urls[$link_id])) {
-            $url    = $this->encodeAttribute($this->urls[$link_id]);
-            $result = "<img src=\"$url\" alt=\"$alt_text\"";
-            if (isset($this->titles[$link_id])) {
-                $title = $this->titles[$link_id];
-                $title = $this->encodeAttribute($title);
-                $result .= " title=\"$title\"";
-            }
-            $result .= $this->empty_element_suffix;
-            $result = $this->hashPart($result);
-        } else {
-            # If there's no such link ID, leave intact:
-            $result = $whole_match;
-        }
-
-        return $result;
-    }
-
-    function _doImages_inline_callback($matches)
-    {
-        $whole_match = $matches[1];
-        $alt_text    = $matches[2];
-        $url         = $matches[3] == '' ? $matches[4] : $matches[3];
-        $title       =& $matches[7];
-
-        $alt_text = $this->encodeAttribute($alt_text);
-        $url      = $this->encodeAttribute($url);
-        $result   = "<img src=\"$url\" alt=\"$alt_text\"";
-        if (isset($title)) {
-            $title = $this->encodeAttribute($title);
-            $result .= " title=\"$title\""; # $title already quoted
-        }
-        $result .= $this->empty_element_suffix;
-
-        return $this->hashPart($result);
-    }
-
-    function doHeaders($text)
-    {
-        # Setext-style headers:
-        #	  Header 1
-        #	  ========
-        #
-        #	  Header 2
-        #	  --------
-        #
-        $text = preg_replace_callback(
-            '{ ^(.+?)[ ]*\n(=+|-+)[ ]*\n+ }mx',
-            array(&$this, '_doHeaders_callback_setext'),
-            $text
-        );
-
-        # atx-style headers:
-        #	# Header 1
-        #	## Header 2
-        #	## Header 2 with closing hashes ##
-        #	...
-        #	###### Header 6
-        #
-        $text = preg_replace_callback(
-            '{
+			array(&$this, '_doImages_inline_callback'),
+			$text
+		);
+
+		return $text;
+	}
+
+	function _doImages_reference_callback($matches)
+	{
+		$whole_match = $matches[1];
+		$alt_text    = $matches[2];
+		$link_id     = strtolower($matches[3]);
+
+		if ($link_id == "") {
+			$link_id = strtolower($alt_text); # for shortcut links like ![this][].
+		}
+
+		$alt_text = $this->encodeAttribute($alt_text);
+		if (isset($this->urls[$link_id])) {
+			$url    = $this->encodeAttribute($this->urls[$link_id]);
+			$result = "<img src=\"$url\" alt=\"$alt_text\"";
+			if (isset($this->titles[$link_id])) {
+				$title = $this->titles[$link_id];
+				$title = $this->encodeAttribute($title);
+				$result .= " title=\"$title\"";
+			}
+			$result .= $this->empty_element_suffix;
+			$result = $this->hashPart($result);
+		} else {
+			# If there's no such link ID, leave intact:
+			$result = $whole_match;
+		}
+
+		return $result;
+	}
+
+	function _doImages_inline_callback($matches)
+	{
+		$whole_match = $matches[1];
+		$alt_text    = $matches[2];
+		$url         = $matches[3] == '' ? $matches[4] : $matches[3];
+		$title       =& $matches[7];
+
+		$alt_text = $this->encodeAttribute($alt_text);
+		$url      = $this->encodeAttribute($url);
+		$result   = "<img src=\"$url\" alt=\"$alt_text\"";
+		if (isset($title)) {
+			$title = $this->encodeAttribute($title);
+			$result .= " title=\"$title\""; # $title already quoted
+		}
+		$result .= $this->empty_element_suffix;
+
+		return $this->hashPart($result);
+	}
+
+	function doHeaders($text)
+	{
+		# Setext-style headers:
+		#	  Header 1
+		#	  ========
+		#
+		#	  Header 2
+		#	  --------
+		#
+		$text = preg_replace_callback(
+			'{ ^(.+?)[ ]*\n(=+|-+)[ ]*\n+ }mx',
+			array(&$this, '_doHeaders_callback_setext'),
+			$text
+		);
+
+		# atx-style headers:
+		#	# Header 1
+		#	## Header 2
+		#	## Header 2 with closing hashes ##
+		#	...
+		#	###### Header 6
+		#
+		$text = preg_replace_callback(
+			'{
 				^(\#{1,6})	# $1 = string of #\'s
 				[ ]*
 				(.+?)		# $2 = Header text
@@ -1002,52 +1002,52 @@ 
 				\#*			# optional closing #\'s (not counted)
 				\n+
 			}xm',
-            array(&$this, '_doHeaders_callback_atx'),
-            $text
-        );
-
-        return $text;
-    }
-
-    function _doHeaders_callback_setext($matches)
-    {
-        # Terrible hack to check we haven't found an empty list item.
-        if ($matches[2] == '-' && preg_match('{^-(?: |$)}', $matches[1])) {
-            return $matches[0];
-        }
-
-        $level = $matches[2]{0} == '=' ? 1 : 2;
-        $block = "<h$level>" . $this->runSpanGamut($matches[1]) . "</h$level>";
-        return "\n" . $this->hashBlock($block) . "\n\n";
-    }
-
-    function _doHeaders_callback_atx($matches)
-    {
-        $level = strlen($matches[1]);
-        $block = "<h$level>" . $this->runSpanGamut($matches[2]) . "</h$level>";
-        return "\n" . $this->hashBlock($block) . "\n\n";
-    }
-
-    function doLists($text)
-    {
-        #
-        # Form HTML ordered (numbered) and unordered (bulleted) lists.
-        #
-        $less_than_tab = $this->tab_width - 1;
-
-        # Re-usable patterns to match list item bullets and number markers:
-        $marker_ul_re  = '[*+-]';
-        $marker_ol_re  = '\d+[\.]';
-        $marker_any_re = "(?:$marker_ul_re|$marker_ol_re)";
-
-        $markers_relist = array(
-            $marker_ul_re => $marker_ol_re,
-            $marker_ol_re => $marker_ul_re,
-        );
-
-        foreach ($markers_relist as $marker_re => $other_marker_re) {
-            # Re-usable pattern to match any entirel ul or ol list:
-            $whole_list_re = '
+			array(&$this, '_doHeaders_callback_atx'),
+			$text
+		);
+
+		return $text;
+	}
+
+	function _doHeaders_callback_setext($matches)
+	{
+		# Terrible hack to check we haven't found an empty list item.
+		if ($matches[2] == '-' && preg_match('{^-(?: |$)}', $matches[1])) {
+			return $matches[0];
+		}
+
+		$level = $matches[2]{0} == '=' ? 1 : 2;
+		$block = "<h$level>" . $this->runSpanGamut($matches[1]) . "</h$level>";
+		return "\n" . $this->hashBlock($block) . "\n\n";
+	}
+
+	function _doHeaders_callback_atx($matches)
+	{
+		$level = strlen($matches[1]);
+		$block = "<h$level>" . $this->runSpanGamut($matches[2]) . "</h$level>";
+		return "\n" . $this->hashBlock($block) . "\n\n";
+	}
+
+	function doLists($text)
+	{
+		#
+		# Form HTML ordered (numbered) and unordered (bulleted) lists.
+		#
+		$less_than_tab = $this->tab_width - 1;
+
+		# Re-usable patterns to match list item bullets and number markers:
+		$marker_ul_re  = '[*+-]';
+		$marker_ol_re  = '\d+[\.]';
+		$marker_any_re = "(?:$marker_ul_re|$marker_ol_re)";
+
+		$markers_relist = array(
+			$marker_ul_re => $marker_ol_re,
+			$marker_ol_re => $marker_ul_re,
+		);
+
+		foreach ($markers_relist as $marker_re => $other_marker_re) {
+			# Re-usable pattern to match any entirel ul or ol list:
+			$whole_list_re = '
 				(								# $1 = whole list
 				  (								# $2
 					([ ]{0,' . $less_than_tab . '})	# $3 = number of spaces
@@ -1074,88 +1074,88 @@ 
 				)
 			'; // mx
 
-            # We use a different prefix before nested lists than top-level lists.
-            # See extended comment in _ProcessListItems().
+			# We use a different prefix before nested lists than top-level lists.
+			# See extended comment in _ProcessListItems().
 
-            if ($this->list_level) {
-                $text = preg_replace_callback(
-                    '{
+			if ($this->list_level) {
+				$text = preg_replace_callback(
+					'{
 						^
 						' . $whole_list_re . '
 					}mx',
-                    array(&$this, '_doLists_callback'),
-                    $text
-                );
-            } else {
-                $text = preg_replace_callback(
-                    '{
+					array(&$this, '_doLists_callback'),
+					$text
+				);
+			} else {
+				$text = preg_replace_callback(
+					'{
 						(?:(?<=\n)\n|\A\n?) # Must eat the newline
 						' . $whole_list_re . '
 					}mx',
-                    array(&$this, '_doLists_callback'),
-                    $text
-                );
-            }
-        }
-
-        return $text;
-    }
-
-    function _doLists_callback($matches)
-    {
-        # Re-usable patterns to match list item bullets and number markers:
-        $marker_ul_re  = '[*+-]';
-        $marker_ol_re  = '\d+[\.]';
-        $marker_any_re = "(?:$marker_ul_re|$marker_ol_re)";
-
-        $list      = $matches[1];
-        $list_type = preg_match("/$marker_ul_re/", $matches[4]) ? "ul" : "ol";
-
-        $marker_any_re = ($list_type == "ul" ? $marker_ul_re : $marker_ol_re);
-
-        $list .= "\n";
-        $result = $this->processListItems($list, $marker_any_re);
-
-        $result = $this->hashBlock("<$list_type>\n" . $result . "</$list_type>");
-        return "\n" . $result . "\n\n";
-    }
-
-    var $list_level = 0;
-
-    function processListItems($list_str, $marker_any_re)
-    {
-        #
-        #	Process the contents of a single ordered or unordered list, splitting it
-        #	into individual list items.
-        #
-        # The $this->list_level global keeps track of when we're inside a list.
-        # Each time we enter a list, we increment it; when we leave a list,
-        # we decrement. If it's zero, we're not in a list anymore.
-        #
-        # We do this because when we're not inside a list, we want to treat
-        # something like this:
-        #
-        #		I recommend upgrading to version
-        #		8. Oops, now this line is treated
-        #		as a sub-list.
-        #
-        # As a single paragraph, despite the fact that the second line starts
-        # with a digit-period-space sequence.
-        #
-        # Whereas when we're inside a list (or sub-list), that line will be
-        # treated as the start of a sub-list. What a kludge, huh? This is
-        # an aspect of Markdown's syntax that's hard to parse perfectly
-        # without resorting to mind-reading. Perhaps the solution is to
-        # change the syntax rules such that sub-lists must start with a
-        # starting cardinal number; e.g. "1." or "a.".
-
-        $this->list_level ++;
-
-        # trim trailing blank lines:
-        $list_str = preg_replace("/\n{2,}\\z/", "\n", $list_str);
-
-        $list_str = preg_replace_callback(
-            '{
+					array(&$this, '_doLists_callback'),
+					$text
+				);
+			}
+		}
+
+		return $text;
+	}
+
+	function _doLists_callback($matches)
+	{
+		# Re-usable patterns to match list item bullets and number markers:
+		$marker_ul_re  = '[*+-]';
+		$marker_ol_re  = '\d+[\.]';
+		$marker_any_re = "(?:$marker_ul_re|$marker_ol_re)";
+
+		$list      = $matches[1];
+		$list_type = preg_match("/$marker_ul_re/", $matches[4]) ? "ul" : "ol";
+
+		$marker_any_re = ($list_type == "ul" ? $marker_ul_re : $marker_ol_re);
+
+		$list .= "\n";
+		$result = $this->processListItems($list, $marker_any_re);
+
+		$result = $this->hashBlock("<$list_type>\n" . $result . "</$list_type>");
+		return "\n" . $result . "\n\n";
+	}
+
+	var $list_level = 0;
+
+	function processListItems($list_str, $marker_any_re)
+	{
+		#
+		#	Process the contents of a single ordered or unordered list, splitting it
+		#	into individual list items.
+		#
+		# The $this->list_level global keeps track of when we're inside a list.
+		# Each time we enter a list, we increment it; when we leave a list,
+		# we decrement. If it's zero, we're not in a list anymore.
+		#
+		# We do this because when we're not inside a list, we want to treat
+		# something like this:
+		#
+		#		I recommend upgrading to version
+		#		8. Oops, now this line is treated
+		#		as a sub-list.
+		#
+		# As a single paragraph, despite the fact that the second line starts
+		# with a digit-period-space sequence.
+		#
+		# Whereas when we're inside a list (or sub-list), that line will be
+		# treated as the start of a sub-list. What a kludge, huh? This is
+		# an aspect of Markdown's syntax that's hard to parse perfectly
+		# without resorting to mind-reading. Perhaps the solution is to
+		# change the syntax rules such that sub-lists must start with a
+		# starting cardinal number; e.g. "1." or "a.".
+
+		$this->list_level ++;
+
+		# trim trailing blank lines:
+		$list_str = preg_replace("/\n{2,}\\z/", "\n", $list_str);
+
+		$list_str = preg_replace_callback(
+			'{
 			(\n)?							# leading line = $1
 			(^[ ]*)							# leading whitespace = $2
 			(' . $marker_any_re . '				# list marker and space = $3
@@ -1165,45 +1165,45 @@ 
 			(?:(\n+(?=\n))|\n)				# tailing blank line = $5
 			(?= \n* (\z | \2 (' . $marker_any_re . ') (?:[ ]+|(?=\n))))
 			}xm',
-            array(&$this, '_processListItems_callback'),
-            $list_str
-        );
-
-        $this->list_level --;
-        return $list_str;
-    }
-
-    function _processListItems_callback($matches)
-    {
-        $item               = $matches[4];
-        $leading_line       =& $matches[1];
-        $leading_space      =& $matches[2];
-        $marker_space       = $matches[3];
-        $tailing_blank_line =& $matches[5];
-
-        if ($leading_line || $tailing_blank_line ||
-            preg_match('/\n{2,}/', $item)
-        ) {
-            # Replace marker with the appropriate whitespace indentation
-            $item = $leading_space . str_repeat(' ', strlen($marker_space)) . $item;
-            $item = $this->runBlockGamut($this->outdent($item) . "\n");
-        } else {
-            # Recursion for sub-lists:
-            $item = $this->doLists($this->outdent($item));
-            $item = preg_replace('/\n+$/', '', $item);
-            $item = $this->runSpanGamut($item);
-        }
-
-        return "<li>" . $item . "</li>\n";
-    }
-
-    function doCodeBlocks($text)
-    {
-        #
-        #	Process Markdown `<pre><code>` blocks.
-        #
-        $text = preg_replace_callback(
-            '{
+			array(&$this, '_processListItems_callback'),
+			$list_str
+		);
+
+		$this->list_level --;
+		return $list_str;
+	}
+
+	function _processListItems_callback($matches)
+	{
+		$item               = $matches[4];
+		$leading_line       =& $matches[1];
+		$leading_space      =& $matches[2];
+		$marker_space       = $matches[3];
+		$tailing_blank_line =& $matches[5];
+
+		if ($leading_line || $tailing_blank_line ||
+			preg_match('/\n{2,}/', $item)
+		) {
+			# Replace marker with the appropriate whitespace indentation
+			$item = $leading_space . str_repeat(' ', strlen($marker_space)) . $item;
+			$item = $this->runBlockGamut($this->outdent($item) . "\n");
+		} else {
+			# Recursion for sub-lists:
+			$item = $this->doLists($this->outdent($item));
+			$item = preg_replace('/\n+$/', '', $item);
+			$item = $this->runSpanGamut($item);
+		}
+
+		return "<li>" . $item . "</li>\n";
+	}
+
+	function doCodeBlocks($text)
+	{
+		#
+		#	Process Markdown `<pre><code>` blocks.
+		#
+		$text = preg_replace_callback(
+			'{
 				(?:\n\n|\A\n?)
 				(	            # $1 = the code block -- one or more lines, starting with a space/tab
 				  (?>
@@ -1213,206 +1213,206 @@ 
 				)
 				((?=^[ ]{0,' . $this->tab_width . '}\S)|\Z)	# Lookahead for non-space at line-start, or end of doc
 			}xm',
-            array(&$this, '_doCodeBlocks_callback'),
-            $text
-        );
-
-        return $text;
-    }
-
-    function _doCodeBlocks_callback($matches)
-    {
-        $codeblock = $matches[1];
-
-        $codeblock = $this->outdent($codeblock);
-        $codeblock = htmlspecialchars($codeblock, ENT_NOQUOTES);
-
-        # trim leading newlines and trailing newlines
-        $codeblock = preg_replace('/\A\n+|\n+\z/', '', $codeblock);
-
-        $codeblock = "<pre><code>$codeblock\n</code></pre>";
-        return "\n\n" . $this->hashBlock($codeblock) . "\n\n";
-    }
-
-    function makeCodeSpan($code)
-    {
-        #
-        # Create a code span markup for $code. Called from handleSpanToken.
-        #
-        $code = htmlspecialchars(trim($code), ENT_NOQUOTES);
-        return $this->hashPart("<code>$code</code>");
-    }
-
-    var $em_relist = array(
-        ''  => '(?:(?<!\*)\*(?!\*)|(?<!_)_(?!_))(?=\S|$)(?![\.,:;]\s)',
-        '*' => '(?<=\S|^)(?<!\*)\*(?!\*)',
-        '_' => '(?<=\S|^)(?<!_)_(?!_)',
-    );
-
-    var $strong_relist = array(
-        ''   => '(?:(?<!\*)\*\*(?!\*)|(?<!_)__(?!_))(?=\S|$)(?![\.,:;]\s)',
-        '**' => '(?<=\S|^)(?<!\*)\*\*(?!\*)',
-        '__' => '(?<=\S|^)(?<!_)__(?!_)',
-    );
-
-    var $em_strong_relist = array(
-        ''    => '(?:(?<!\*)\*\*\*(?!\*)|(?<!_)___(?!_))(?=\S|$)(?![\.,:;]\s)',
-        '***' => '(?<=\S|^)(?<!\*)\*\*\*(?!\*)',
-        '___' => '(?<=\S|^)(?<!_)___(?!_)',
-    );
-
-    var $em_strong_prepared_relist;
-
-    function prepareItalicsAndBold()
-    {
-        #
-        # Prepare regular expressions for searching emphasis tokens in any
-        # context.
-        #
-        foreach ($this->em_relist as $em => $em_re) {
-            foreach ($this->strong_relist as $strong => $strong_re) {
-                # Construct list of allowed token expressions.
-                $token_relist = array();
-                if (isset($this->em_strong_relist["$em$strong"])) {
-                    $token_relist[] = $this->em_strong_relist["$em$strong"];
-                }
-                $token_relist[] = $em_re;
-                $token_relist[] = $strong_re;
-
-                # Construct master expression from list.
-                $token_re                                      = '{(' . implode('|', $token_relist) . ')}';
-                $this->em_strong_prepared_relist["$em$strong"] = $token_re;
-            }
-        }
-    }
-
-    function doItalicsAndBold($text)
-    {
-        $token_stack  = array('');
-        $text_stack   = array('');
-        $em           = '';
-        $strong       = '';
-        $tree_char_em = false;
-
-        while (1) {
-            #
-            # Get prepared regular expression for seraching emphasis tokens
-            # in current context.
-            #
-            $token_re = $this->em_strong_prepared_relist["$em$strong"];
-
-            #
-            # Each loop iteration search for the next emphasis token.
-            # Each token is then passed to handleSpanToken.
-            #
-            $parts = preg_split($token_re, $text, 2, PREG_SPLIT_DELIM_CAPTURE);
-            $text_stack[0] .= $parts[0];
-            $token =& $parts[1];
-            $text  =& $parts[2];
-
-            if (empty($token)) {
-                # Reached end of text span: empty stack without emitting.
-                # any more emphasis.
-                while ($token_stack[0]) {
-                    $text_stack[1] .= array_shift($token_stack);
-                    $text_stack[0] .= array_shift($text_stack);
-                }
-                break;
-            }
-
-            $token_len = strlen($token);
-            if ($tree_char_em) {
-                # Reached closing marker while inside a three-char emphasis.
-                if ($token_len == 3) {
-                    # Three-char closing marker, close em and strong.
-                    array_shift($token_stack);
-                    $span = array_shift($text_stack);
-                    $span = $this->runSpanGamut($span);
-                    $span = "<strong><em>$span</em></strong>";
-                    $text_stack[0] .= $this->hashPart($span);
-                    $em     = '';
-                    $strong = '';
-                } else {
-                    # Other closing marker: close one em or strong and
-                    # change current token state to match the other
-                    $token_stack[0] = str_repeat($token{0}, 3 - $token_len);
-                    $tag            = $token_len == 2 ? "strong" : "em";
-                    $span           = $text_stack[0];
-                    $span           = $this->runSpanGamut($span);
-                    $span           = "<$tag>$span</$tag>";
-                    $text_stack[0]  = $this->hashPart($span);
-                    $$tag           = ''; # $$tag stands for $em or $strong
-                }
-                $tree_char_em = false;
-            } else if ($token_len == 3) {
-                if ($em) {
-                    # Reached closing marker for both em and strong.
-                    # Closing strong marker:
-                    for ($i = 0; $i < 2; ++ $i) {
-                        $shifted_token = array_shift($token_stack);
-                        $tag           = strlen($shifted_token) == 2 ? "strong" : "em";
-                        $span          = array_shift($text_stack);
-                        $span          = $this->runSpanGamut($span);
-                        $span          = "<$tag>$span</$tag>";
-                        $text_stack[0] .= $this->hashPart($span);
-                        $$tag = ''; # $$tag stands for $em or $strong
-                    }
-                } else {
-                    # Reached opening three-char emphasis marker. Push on token
-                    # stack; will be handled by the special condition above.
-                    $em     = $token{0};
-                    $strong = "$em$em";
-                    array_unshift($token_stack, $token);
-                    array_unshift($text_stack, '');
-                    $tree_char_em = true;
-                }
-            } else if ($token_len == 2) {
-                if ($strong) {
-                    # Unwind any dangling emphasis marker:
-                    if (strlen($token_stack[0]) == 1) {
-                        $text_stack[1] .= array_shift($token_stack);
-                        $text_stack[0] .= array_shift($text_stack);
-                    }
-                    # Closing strong marker:
-                    array_shift($token_stack);
-                    $span = array_shift($text_stack);
-                    $span = $this->runSpanGamut($span);
-                    $span = "<strong>$span</strong>";
-                    $text_stack[0] .= $this->hashPart($span);
-                    $strong = '';
-                } else {
-                    array_unshift($token_stack, $token);
-                    array_unshift($text_stack, '');
-                    $strong = $token;
-                }
-            } else {
-                # Here $token_len == 1
-                if ($em) {
-                    if (strlen($token_stack[0]) == 1) {
-                        # Closing emphasis marker:
-                        array_shift($token_stack);
-                        $span = array_shift($text_stack);
-                        $span = $this->runSpanGamut($span);
-                        $span = "<em>$span</em>";
-                        $text_stack[0] .= $this->hashPart($span);
-                        $em = '';
-                    } else {
-                        $text_stack[0] .= $token;
-                    }
-                } else {
-                    array_unshift($token_stack, $token);
-                    array_unshift($text_stack, '');
-                    $em = $token;
-                }
-            }
-        }
-        return $text_stack[0];
-    }
-
-    function doBlockQuotes($text)
-    {
-        $text = preg_replace_callback(
-            '/
+			array(&$this, '_doCodeBlocks_callback'),
+			$text
+		);
+
+		return $text;
+	}
+
+	function _doCodeBlocks_callback($matches)
+	{
+		$codeblock = $matches[1];
+
+		$codeblock = $this->outdent($codeblock);
+		$codeblock = htmlspecialchars($codeblock, ENT_NOQUOTES);
+
+		# trim leading newlines and trailing newlines
+		$codeblock = preg_replace('/\A\n+|\n+\z/', '', $codeblock);
+
+		$codeblock = "<pre><code>$codeblock\n</code></pre>";
+		return "\n\n" . $this->hashBlock($codeblock) . "\n\n";
+	}
+
+	function makeCodeSpan($code)
+	{
+		#
+		# Create a code span markup for $code. Called from handleSpanToken.
+		#
+		$code = htmlspecialchars(trim($code), ENT_NOQUOTES);
+		return $this->hashPart("<code>$code</code>");
+	}
+
+	var $em_relist = array(
+		''  => '(?:(?<!\*)\*(?!\*)|(?<!_)_(?!_))(?=\S|$)(?![\.,:;]\s)',
+		'*' => '(?<=\S|^)(?<!\*)\*(?!\*)',
+		'_' => '(?<=\S|^)(?<!_)_(?!_)',
+	);
+
+	var $strong_relist = array(
+		''   => '(?:(?<!\*)\*\*(?!\*)|(?<!_)__(?!_))(?=\S|$)(?![\.,:;]\s)',
+		'**' => '(?<=\S|^)(?<!\*)\*\*(?!\*)',
+		'__' => '(?<=\S|^)(?<!_)__(?!_)',
+	);
+
+	var $em_strong_relist = array(
+		''    => '(?:(?<!\*)\*\*\*(?!\*)|(?<!_)___(?!_))(?=\S|$)(?![\.,:;]\s)',
+		'***' => '(?<=\S|^)(?<!\*)\*\*\*(?!\*)',
+		'___' => '(?<=\S|^)(?<!_)___(?!_)',
+	);
+
+	var $em_strong_prepared_relist;
+
+	function prepareItalicsAndBold()
+	{
+		#
+		# Prepare regular expressions for searching emphasis tokens in any
+		# context.
+		#
+		foreach ($this->em_relist as $em => $em_re) {
+			foreach ($this->strong_relist as $strong => $strong_re) {
+				# Construct list of allowed token expressions.
+				$token_relist = array();
+				if (isset($this->em_strong_relist["$em$strong"])) {
+					$token_relist[] = $this->em_strong_relist["$em$strong"];
+				}
+				$token_relist[] = $em_re;
+				$token_relist[] = $strong_re;
+
+				# Construct master expression from list.
+				$token_re                                      = '{(' . implode('|', $token_relist) . ')}';
+				$this->em_strong_prepared_relist["$em$strong"] = $token_re;
+			}
+		}
+	}
+
+	function doItalicsAndBold($text)
+	{
+		$token_stack  = array('');
+		$text_stack   = array('');
+		$em           = '';
+		$strong       = '';
+		$tree_char_em = false;
+
+		while (1) {
+			#
+			# Get prepared regular expression for seraching emphasis tokens
+			# in current context.
+			#
+			$token_re = $this->em_strong_prepared_relist["$em$strong"];
+
+			#
+			# Each loop iteration search for the next emphasis token.
+			# Each token is then passed to handleSpanToken.
+			#
+			$parts = preg_split($token_re, $text, 2, PREG_SPLIT_DELIM_CAPTURE);
+			$text_stack[0] .= $parts[0];
+			$token =& $parts[1];
+			$text  =& $parts[2];
+
+			if (empty($token)) {
+				# Reached end of text span: empty stack without emitting.
+				# any more emphasis.
+				while ($token_stack[0]) {
+					$text_stack[1] .= array_shift($token_stack);
+					$text_stack[0] .= array_shift($text_stack);
+				}
+				break;
+			}
+
+			$token_len = strlen($token);
+			if ($tree_char_em) {
+				# Reached closing marker while inside a three-char emphasis.
+				if ($token_len == 3) {
+					# Three-char closing marker, close em and strong.
+					array_shift($token_stack);
+					$span = array_shift($text_stack);
+					$span = $this->runSpanGamut($span);
+					$span = "<strong><em>$span</em></strong>";
+					$text_stack[0] .= $this->hashPart($span);
+					$em     = '';
+					$strong = '';
+				} else {
+					# Other closing marker: close one em or strong and
+					# change current token state to match the other
+					$token_stack[0] = str_repeat($token{0}, 3 - $token_len);
+					$tag            = $token_len == 2 ? "strong" : "em";
+					$span           = $text_stack[0];
+					$span           = $this->runSpanGamut($span);
+					$span           = "<$tag>$span</$tag>";
+					$text_stack[0]  = $this->hashPart($span);
+					$$tag           = ''; # $$tag stands for $em or $strong
+				}
+				$tree_char_em = false;
+			} else if ($token_len == 3) {
+				if ($em) {
+					# Reached closing marker for both em and strong.
+					# Closing strong marker:
+					for ($i = 0; $i < 2; ++ $i) {
+						$shifted_token = array_shift($token_stack);
+						$tag           = strlen($shifted_token) == 2 ? "strong" : "em";
+						$span          = array_shift($text_stack);
+						$span          = $this->runSpanGamut($span);
+						$span          = "<$tag>$span</$tag>";
+						$text_stack[0] .= $this->hashPart($span);
+						$$tag = ''; # $$tag stands for $em or $strong
+					}
+				} else {
+					# Reached opening three-char emphasis marker. Push on token
+					# stack; will be handled by the special condition above.
+					$em     = $token{0};
+					$strong = "$em$em";
+					array_unshift($token_stack, $token);
+					array_unshift($text_stack, '');
+					$tree_char_em = true;
+				}
+			} else if ($token_len == 2) {
+				if ($strong) {
+					# Unwind any dangling emphasis marker:
+					if (strlen($token_stack[0]) == 1) {
+						$text_stack[1] .= array_shift($token_stack);
+						$text_stack[0] .= array_shift($text_stack);
+					}
+					# Closing strong marker:
+					array_shift($token_stack);
+					$span = array_shift($text_stack);
+					$span = $this->runSpanGamut($span);
+					$span = "<strong>$span</strong>";
+					$text_stack[0] .= $this->hashPart($span);
+					$strong = '';
+				} else {
+					array_unshift($token_stack, $token);
+					array_unshift($text_stack, '');
+					$strong = $token;
+				}
+			} else {
+				# Here $token_len == 1
+				if ($em) {
+					if (strlen($token_stack[0]) == 1) {
+						# Closing emphasis marker:
+						array_shift($token_stack);
+						$span = array_shift($text_stack);
+						$span = $this->runSpanGamut($span);
+						$span = "<em>$span</em>";
+						$text_stack[0] .= $this->hashPart($span);
+						$em = '';
+					} else {
+						$text_stack[0] .= $token;
+					}
+				} else {
+					array_unshift($token_stack, $token);
+					array_unshift($text_stack, '');
+					$em = $token;
+				}
+			}
+		}
+		return $text_stack[0];
+	}
+
+	function doBlockQuotes($text)
+	{
+		$text = preg_replace_callback(
+			'/
 			  (								# Wrap whole match in $1
 				(?>
 				  ^[ ]*>[ ]?			# ">" at the start of a line
@@ -1422,66 +1422,66 @@ 
 				)+
 			  )
 			/xm',
-            array(&$this, '_doBlockQuotes_callback'),
-            $text
-        );
-
-        return $text;
-    }
-
-    function _doBlockQuotes_callback($matches)
-    {
-        $bq = $matches[1];
-        # trim one level of quoting - trim whitespace-only lines
-        $bq = preg_replace('/^[ ]*>[ ]?|^[ ]+$/m', '', $bq);
-        $bq = $this->runBlockGamut($bq); # recurse
-
-        $bq = preg_replace('/^/m', "  ", $bq);
-        # These leading spaces cause problem with <pre> content,
-        # so we need to fix that:
-        $bq = preg_replace_callback(
-            '{(\s*<pre>.+?</pre>)}sx',
-            array(&$this, '_doBlockQuotes_callback2'),
-            $bq
-        );
-
-        return "\n" . $this->hashBlock("<blockquote>\n$bq\n</blockquote>") . "\n\n";
-    }
-
-    function _doBlockQuotes_callback2($matches)
-    {
-        $pre = $matches[1];
-        $pre = preg_replace('/^  /m', '', $pre);
-        return $pre;
-    }
-
-    function formParagraphs($text)
-    {
-        #
-        #	Params:
-        #		$text - string to process with html <p> tags
-        #
-        # Strip leading and trailing lines:
-        $text = preg_replace('/\A\n+|\n+\z/', '', $text);
-
-        $grafs = preg_split('/\n{2,}/', $text, - 1, PREG_SPLIT_NO_EMPTY);
-
-        #
-        # Wrap <p> tags and unhashify HTML blocks
-        #
-        foreach ($grafs as $key => $value) {
-            if (!preg_match('/^B\x1A[0-9]+B$/', $value)) {
-                # Is a paragraph.
-                $value = $this->runSpanGamut($value);
-                $value = preg_replace('/^([ ]*)/', "<p>", $value);
-                $value .= "</p>";
-                $grafs[$key] = $this->unhash($value);
-            } else {
-                # Is a block.
-                # Modify elements of @grafs in-place...
-                $graf  = $value;
-                $block = $this->html_hashes[$graf];
-                $graf  = $block;
+			array(&$this, '_doBlockQuotes_callback'),
+			$text
+		);
+
+		return $text;
+	}
+
+	function _doBlockQuotes_callback($matches)
+	{
+		$bq = $matches[1];
+		# trim one level of quoting - trim whitespace-only lines
+		$bq = preg_replace('/^[ ]*>[ ]?|^[ ]+$/m', '', $bq);
+		$bq = $this->runBlockGamut($bq); # recurse
+
+		$bq = preg_replace('/^/m', "  ", $bq);
+		# These leading spaces cause problem with <pre> content,
+		# so we need to fix that:
+		$bq = preg_replace_callback(
+			'{(\s*<pre>.+?</pre>)}sx',
+			array(&$this, '_doBlockQuotes_callback2'),
+			$bq
+		);
+
+		return "\n" . $this->hashBlock("<blockquote>\n$bq\n</blockquote>") . "\n\n";
+	}
+
+	function _doBlockQuotes_callback2($matches)
+	{
+		$pre = $matches[1];
+		$pre = preg_replace('/^  /m', '', $pre);
+		return $pre;
+	}
+
+	function formParagraphs($text)
+	{
+		#
+		#	Params:
+		#		$text - string to process with html <p> tags
+		#
+		# Strip leading and trailing lines:
+		$text = preg_replace('/\A\n+|\n+\z/', '', $text);
+
+		$grafs = preg_split('/\n{2,}/', $text, - 1, PREG_SPLIT_NO_EMPTY);
+
+		#
+		# Wrap <p> tags and unhashify HTML blocks
+		#
+		foreach ($grafs as $key => $value) {
+			if (!preg_match('/^B\x1A[0-9]+B$/', $value)) {
+				# Is a paragraph.
+				$value = $this->runSpanGamut($value);
+				$value = preg_replace('/^([ ]*)/', "<p>", $value);
+				$value .= "</p>";
+				$grafs[$key] = $this->unhash($value);
+			} else {
+				# Is a block.
+				# Modify elements of @grafs in-place...
+				$graf  = $value;
+				$block = $this->html_hashes[$graf];
+				$graf  = $block;
 //				if (preg_match('{
 //					\A
 //					(							# $1 = <div> tag
@@ -1517,59 +1517,59 @@ 
 //
 //					$graf = $div_open . "\n" . $div_content . "\n" . $div_close;
 //				}
-                $grafs[$key] = $graf;
-            }
-        }
-
-        return implode("\n\n", $grafs);
-    }
-
-    function encodeAttribute($text)
-    {
-        #
-        # Encode text for a double-quoted HTML attribute. This function
-        # is *not* suitable for attributes enclosed in single quotes.
-        #
-        $text = $this->encodeAmpsAndAngles($text);
-        $text = str_replace('"', '&quot;', $text);
-        return $text;
-    }
-
-    function encodeAmpsAndAngles($text)
-    {
-        #
-        # Smart processing for ampersands and angle brackets that need to
-        # be encoded. Valid character entities are left alone unless the
-        # no-entities mode is set.
-        #
-        if ($this->no_entities) {
-            $text = str_replace('&', '&amp;', $text);
-        } else {
-            # Ampersand-encoding based entirely on Nat Irons's Amputator
-            # MT plugin: <http://bumppo.net/projects/amputator/>
-            $text = preg_replace(
-                '/&(?!#?[xX]?(?:[0-9a-fA-F]+|\w+);)/',
-                '&amp;',
-                $text
-            );;
-        }
-        # Encode remaining <'s
-        $text = str_replace('<', '&lt;', $text);
-
-        return $text;
-    }
-
-    function doAutoLinks($text)
-    {
-        $text = preg_replace_callback(
-            '{<((https?|ftp|dict):[^\'">\s]+)>}i',
-            array(&$this, '_doAutoLinks_url_callback'),
-            $text
-        );
-
-        # Email addresses: <address@domain.foo>
-        $text = preg_replace_callback(
-            '{
+				$grafs[$key] = $graf;
+			}
+		}
+
+		return implode("\n\n", $grafs);
+	}
+
+	function encodeAttribute($text)
+	{
+		#
+		# Encode text for a double-quoted HTML attribute. This function
+		# is *not* suitable for attributes enclosed in single quotes.
+		#
+		$text = $this->encodeAmpsAndAngles($text);
+		$text = str_replace('"', '&quot;', $text);
+		return $text;
+	}
+
+	function encodeAmpsAndAngles($text)
+	{
+		#
+		# Smart processing for ampersands and angle brackets that need to
+		# be encoded. Valid character entities are left alone unless the
+		# no-entities mode is set.
+		#
+		if ($this->no_entities) {
+			$text = str_replace('&', '&amp;', $text);
+		} else {
+			# Ampersand-encoding based entirely on Nat Irons's Amputator
+			# MT plugin: <http://bumppo.net/projects/amputator/>
+			$text = preg_replace(
+				'/&(?!#?[xX]?(?:[0-9a-fA-F]+|\w+);)/',
+				'&amp;',
+				$text
+			);;
+		}
+		# Encode remaining <'s
+		$text = str_replace('<', '&lt;', $text);
+
+		return $text;
+	}
+
+	function doAutoLinks($text)
+	{
+		$text = preg_replace_callback(
+			'{<((https?|ftp|dict):[^\'">\s]+)>}i',
+			array(&$this, '_doAutoLinks_url_callback'),
+			$text
+		);
+
+		# Email addresses: <address@domain.foo>
+		$text = preg_replace_callback(
+			'{
 			<
 			(?:mailto:)?
 			(
@@ -1587,81 +1587,81 @@ 
 			)
 			>
 			}xi',
-            array(&$this, '_doAutoLinks_email_callback'),
-            $text
-        );
-
-        return $text;
-    }
-
-    function _doAutoLinks_url_callback($matches)
-    {
-        $url  = $this->encodeAttribute($matches[1]);
-        $link = "<a href=\"$url\">$url</a>";
-        return $this->hashPart($link);
-    }
-
-    function _doAutoLinks_email_callback($matches)
-    {
-        $address = $matches[1];
-        $link    = $this->encodeEmailAddress($address);
-        return $this->hashPart($link);
-    }
-
-    function encodeEmailAddress($addr)
-    {
-        #
-        #	Input: an email address, e.g. "foo@example.com"
-        #
-        #	Output: the email address as a mailto link, with each character
-        #		of the address encoded as either a decimal or hex entity, in
-        #		the hopes of foiling most address harvesting spam bots. E.g.:
-        #
-        #	  <p><a href="&#109;&#x61;&#105;&#x6c;&#116;&#x6f;&#58;&#x66;o&#111;
-        #        &#x40;&#101;&#x78;&#97;&#x6d;&#112;&#x6c;&#101;&#46;&#x63;&#111;
-        #        &#x6d;">&#x66;o&#111;&#x40;&#101;&#x78;&#97;&#x6d;&#112;&#x6c;
-        #        &#101;&#46;&#x63;&#111;&#x6d;</a></p>
-        #
-        #	Based by a filter by Matthew Wickline, posted to BBEdit-Talk.
-        #   With some optimizations by Milian Wolff.
-        #
-        $addr  = "mailto:" . $addr;
-        $chars = preg_split('/(?<!^)(?!$)/', $addr);
-        $seed  = (int)abs(crc32($addr) / strlen($addr)); # Deterministic seed.
-
-        foreach ($chars as $key => $char) {
-            $ord = ord($char);
-            # Ignore non-ascii chars.
-            if ($ord < 128) {
-                $r = ($seed * (1 + $key)) % 100; # Pseudo-random function.
-                # roughly 10% raw, 45% hex, 45% dec
-                # '@' *must* be encoded. I insist.
-                if ($r > 90 && $char != '@') /* do nothing */ {
-                    ;
-                } else if ($r < 45) {
-                    $chars[$key] = '&#x' . dechex($ord) . ';';
-                } else {
-                    $chars[$key] = '&#' . $ord . ';';
-                }
-            }
-        }
-
-        $addr = implode('', $chars);
-        $text = implode('', array_slice($chars, 7)); # text without `mailto:`
-        $addr = "<a href=\"$addr\">$text</a>";
-
-        return $addr;
-    }
-
-    function parseSpan($str)
-    {
-        #
-        # Take the string $str and parse it into tokens, hashing embeded HTML,
-        # escaped characters and handling code spans.
-        #
-        $output = '';
-
-        $span_re = '{
+			array(&$this, '_doAutoLinks_email_callback'),
+			$text
+		);
+
+		return $text;
+	}
+
+	function _doAutoLinks_url_callback($matches)
+	{
+		$url  = $this->encodeAttribute($matches[1]);
+		$link = "<a href=\"$url\">$url</a>";
+		return $this->hashPart($link);
+	}
+
+	function _doAutoLinks_email_callback($matches)
+	{
+		$address = $matches[1];
+		$link    = $this->encodeEmailAddress($address);
+		return $this->hashPart($link);
+	}
+
+	function encodeEmailAddress($addr)
+	{
+		#
+		#	Input: an email address, e.g. "foo@example.com"
+		#
+		#	Output: the email address as a mailto link, with each character
+		#		of the address encoded as either a decimal or hex entity, in
+		#		the hopes of foiling most address harvesting spam bots. E.g.:
+		#
+		#	  <p><a href="&#109;&#x61;&#105;&#x6c;&#116;&#x6f;&#58;&#x66;o&#111;
+		#        &#x40;&#101;&#x78;&#97;&#x6d;&#112;&#x6c;&#101;&#46;&#x63;&#111;
+		#        &#x6d;">&#x66;o&#111;&#x40;&#101;&#x78;&#97;&#x6d;&#112;&#x6c;
+		#        &#101;&#46;&#x63;&#111;&#x6d;</a></p>
+		#
+		#	Based by a filter by Matthew Wickline, posted to BBEdit-Talk.
+		#   With some optimizations by Milian Wolff.
+		#
+		$addr  = "mailto:" . $addr;
+		$chars = preg_split('/(?<!^)(?!$)/', $addr);
+		$seed  = (int)abs(crc32($addr) / strlen($addr)); # Deterministic seed.
+
+		foreach ($chars as $key => $char) {
+			$ord = ord($char);
+			# Ignore non-ascii chars.
+			if ($ord < 128) {
+				$r = ($seed * (1 + $key)) % 100; # Pseudo-random function.
+				# roughly 10% raw, 45% hex, 45% dec
+				# '@' *must* be encoded. I insist.
+				if ($r > 90 && $char != '@') /* do nothing */ {
+					;
+				} else if ($r < 45) {
+					$chars[$key] = '&#x' . dechex($ord) . ';';
+				} else {
+					$chars[$key] = '&#' . $ord . ';';
+				}
+			}
+		}
+
+		$addr = implode('', $chars);
+		$text = implode('', array_slice($chars, 7)); # text without `mailto:`
+		$addr = "<a href=\"$addr\">$text</a>";
+
+		return $addr;
+	}
+
+	function parseSpan($str)
+	{
+		#
+		# Take the string $str and parse it into tokens, hashing embeded HTML,
+		# escaped characters and handling code spans.
+		#
+		$output = '';
+
+		$span_re = '{
 				(
 					\\\\' . $this->escape_chars_re . '
 				|
@@ -1687,142 +1687,142 @@ 
 				)
 				}xs';
 
-        while (1) {
-            #
-            # Each loop iteration seach for either the next tag, the next
-            # openning code span marker, or the next escaped character.
-            # Each token is then passed to handleSpanToken.
-            #
-            $parts = preg_split($span_re, $str, 2, PREG_SPLIT_DELIM_CAPTURE);
-
-            # Create token from text preceding tag.
-            if ($parts[0] != "") {
-                $output .= $parts[0];
-            }
-
-            # Check if we reach the end.
-            if (isset($parts[1])) {
-                $output .= $this->handleSpanToken($parts[1], $parts[2]);
-                $str = $parts[2];
-            } else {
-                break;
-            }
-        }
-
-        return $output;
-    }
-
-    function handleSpanToken($token, &$str)
-    {
-        #
-        # Handle $token provided by parseSpan by determining its nature and
-        # returning the corresponding value that should replace it.
-        #
-        switch ($token{0}) {
-            case "\\":
-                return $this->hashPart("&#" . ord($token{1}) . ";");
-            case "`":
-                # Search for end marker in remaining text.
-                if (preg_match(
-                    '/^(.*?[^`])' . preg_quote($token) . '(?!`)(.*)$/sm',
-                    $str,
-                    $matches
-                )) {
-                    $str      = $matches[2];
-                    $codespan = $this->makeCodeSpan($matches[1]);
-                    return $this->hashPart($codespan);
-                }
-                return $token; // return as text since no ending marker found.
-            default:
-                return $this->hashPart($token);
-        }
-    }
-
-    function outdent($text)
-    {
-        #
-        # Remove one level of line-leading tabs or spaces
-        #
-        return preg_replace('/^(\t|[ ]{1,' . $this->tab_width . '})/m', '', $text);
-    }
-
-
-    # String length function for detab. `_initDetab` will create a function to
-    # hanlde UTF-8 if the default function does not exist.
-    var $utf8_strlen = 'mb_strlen';
-
-    function detab($text)
-    {
-        #
-        # Replace tabs with the appropriate amount of space.
-        #
-        # For each line we separate the line in blocks delemited by
-        # tab characters. Then we reconstruct every line by adding the
-        # appropriate number of space between each blocks.
-
-        $text = preg_replace_callback(
-            '/^.*\t.*$/m',
-            array(&$this, '_detab_callback'),
-            $text
-        );
-
-        return $text;
-    }
-
-    function _detab_callback($matches)
-    {
-        $line   = $matches[0];
-        $strlen = $this->utf8_strlen; # strlen function for UTF-8.
-
-        # Split in blocks.
-        $blocks = explode("\t", $line);
-        # Add each blocks to the line.
-        $line = $blocks[0];
-        unset($blocks[0]); # Do not add first block twice.
-        foreach ($blocks as $block) {
-            # Calculate amount of space, insert spaces, insert block.
-            $amount = $this->tab_width -
-                      $strlen($line, 'UTF-8') % $this->tab_width;
-            $line .= str_repeat(" ", $amount) . $block;
-        }
-        return $line;
-    }
-
-    function _initDetab()
-    {
-        #
-        # Check for the availability of the function in the `utf8_strlen` property
-        # (initially `mb_strlen`). If the function is not available, create a
-        # function that will loosely count the number of UTF-8 characters with a
-        # regular expression.
-        #
-        if (function_exists($this->utf8_strlen)) {
-            return;
-        }
-        $this->utf8_strlen = create_function(
-            '$text',
-            'return preg_match_all(
+		while (1) {
+			#
+			# Each loop iteration seach for either the next tag, the next
+			# openning code span marker, or the next escaped character.
+			# Each token is then passed to handleSpanToken.
+			#
+			$parts = preg_split($span_re, $str, 2, PREG_SPLIT_DELIM_CAPTURE);
+
+			# Create token from text preceding tag.
+			if ($parts[0] != "") {
+				$output .= $parts[0];
+			}
+
+			# Check if we reach the end.
+			if (isset($parts[1])) {
+				$output .= $this->handleSpanToken($parts[1], $parts[2]);
+				$str = $parts[2];
+			} else {
+				break;
+			}
+		}
+
+		return $output;
+	}
+
+	function handleSpanToken($token, &$str)
+	{
+		#
+		# Handle $token provided by parseSpan by determining its nature and
+		# returning the corresponding value that should replace it.
+		#
+		switch ($token{0}) {
+			case "\\":
+				return $this->hashPart("&#" . ord($token{1}) . ";");
+			case "`":
+				# Search for end marker in remaining text.
+				if (preg_match(
+					'/^(.*?[^`])' . preg_quote($token) . '(?!`)(.*)$/sm',
+					$str,
+					$matches
+				)) {
+					$str      = $matches[2];
+					$codespan = $this->makeCodeSpan($matches[1]);
+					return $this->hashPart($codespan);
+				}
+				return $token; // return as text since no ending marker found.
+			default:
+				return $this->hashPart($token);
+		}
+	}
+
+	function outdent($text)
+	{
+		#
+		# Remove one level of line-leading tabs or spaces
+		#
+		return preg_replace('/^(\t|[ ]{1,' . $this->tab_width . '})/m', '', $text);
+	}
+
+
+	# String length function for detab. `_initDetab` will create a function to
+	# hanlde UTF-8 if the default function does not exist.
+	var $utf8_strlen = 'mb_strlen';
+
+	function detab($text)
+	{
+		#
+		# Replace tabs with the appropriate amount of space.
+		#
+		# For each line we separate the line in blocks delemited by
+		# tab characters. Then we reconstruct every line by adding the
+		# appropriate number of space between each blocks.
+
+		$text = preg_replace_callback(
+			'/^.*\t.*$/m',
+			array(&$this, '_detab_callback'),
+			$text
+		);
+
+		return $text;
+	}
+
+	function _detab_callback($matches)
+	{
+		$line   = $matches[0];
+		$strlen = $this->utf8_strlen; # strlen function for UTF-8.
+
+		# Split in blocks.
+		$blocks = explode("\t", $line);
+		# Add each blocks to the line.
+		$line = $blocks[0];
+		unset($blocks[0]); # Do not add first block twice.
+		foreach ($blocks as $block) {
+			# Calculate amount of space, insert spaces, insert block.
+			$amount = $this->tab_width -
+					  $strlen($line, 'UTF-8') % $this->tab_width;
+			$line .= str_repeat(" ", $amount) . $block;
+		}
+		return $line;
+	}
+
+	function _initDetab()
+	{
+		#
+		# Check for the availability of the function in the `utf8_strlen` property
+		# (initially `mb_strlen`). If the function is not available, create a
+		# function that will loosely count the number of UTF-8 characters with a
+		# regular expression.
+		#
+		if (function_exists($this->utf8_strlen)) {
+			return;
+		}
+		$this->utf8_strlen = create_function(
+			'$text',
+			'return preg_match_all(
 			"/[\\\\x00-\\\\xBF]|[\\\\xC0-\\\\xFF][\\\\x80-\\\\xBF]*/",
 			$text, $m);'
-        );
-    }
-
-    function unhash($text)
-    {
-        #
-        # Swap back in all the tags hashed by _HashHTMLBlocks.
-        #
-        return preg_replace_callback(
-            '/(.)\x1A[0-9]+\1/',
-            array(&$this, '_unhash_callback'),
-            $text
-        );
-    }
-
-    function _unhash_callback($matches)
-    {
-        return $this->html_hashes[$matches[0]];
-    }
+		);
+	}
+
+	function unhash($text)
+	{
+		#
+		# Swap back in all the tags hashed by _HashHTMLBlocks.
+		#
+		return preg_replace_callback(
+			'/(.)\x1A[0-9]+\1/',
+			array(&$this, '_unhash_callback'),
+			$text
+		);
+	}
+
+	function _unhash_callback($matches)
+	{
+		return $this->html_hashes[$matches[0]];
+	}
 }
 
 #
@@ -1832,178 +1832,178 @@ 
 class MarkdownExtra_Parser extends Markdown_Parser
 {
 
-    ### Configuration Variables ###
-
-    # Prefix for footnote ids.
-    var $fn_id_prefix = "";
-
-    # Optional title attribute for footnote links and backlinks.
-    var $fn_link_title = MARKDOWN_FN_LINK_TITLE;
-
-    var $fn_backlink_title = MARKDOWN_FN_BACKLINK_TITLE;
-
-    # Optional class attribute for footnote links and backlinks.
-    var $fn_link_class = MARKDOWN_FN_LINK_CLASS;
-
-    var $fn_backlink_class = MARKDOWN_FN_BACKLINK_CLASS;
-
-    # Optional class prefix for fenced code block.
-    var $code_class_prefix = MARKDOWN_CODE_CLASS_PREFIX;
+	### Configuration Variables ###
+
+	# Prefix for footnote ids.
+	var $fn_id_prefix = "";
+
+	# Optional title attribute for footnote links and backlinks.
+	var $fn_link_title = MARKDOWN_FN_LINK_TITLE;
+
+	var $fn_backlink_title = MARKDOWN_FN_BACKLINK_TITLE;
+
+	# Optional class attribute for footnote links and backlinks.
+	var $fn_link_class = MARKDOWN_FN_LINK_CLASS;
+
+	var $fn_backlink_class = MARKDOWN_FN_BACKLINK_CLASS;
+
+	# Optional class prefix for fenced code block.
+	var $code_class_prefix = MARKDOWN_CODE_CLASS_PREFIX;
 
-    # Class attribute for code blocks goes on the `code` tag;
-    # setting this to true will put attributes on the `pre` tag instead.
-    var $code_attr_on_pre = MARKDOWN_CODE_ATTR_ON_PRE;
+	# Class attribute for code blocks goes on the `code` tag;
+	# setting this to true will put attributes on the `pre` tag instead.
+	var $code_attr_on_pre = MARKDOWN_CODE_ATTR_ON_PRE;
 
-    # Predefined abbreviations.
-    var $predef_abbr = array();
-
-    ### Parser Implementation ###
-
-    function __construct()
-    {
-        #
-        # Constructor function. Initialize the parser object.
-        #
-        # Add extra escapable characters before parent constructor
-        # initialize the table.
-        $this->escape_chars .= ':|';
-
-        # Insert extra document, block, and span transformations.
-        # Parent constructor will do the sorting.
-        $this->document_gamut += array(
-            "doFencedCodeBlocks" => 5,
-            "stripFootnotes"     => 15,
-            "stripAbbreviations" => 25,
-            "appendFootnotes"    => 50,
-        );
-        $this->block_gamut += array(
-            "doFencedCodeBlocks" => 5,
-            "doTables"           => 15,
-            "doDefLists"         => 45,
-        );
-        $this->span_gamut += array(
-            "doFootnotes"     => 5,
-            "doAbbreviations" => 70,
-        );
-
-        parent::__construct();
-    }
-
-    # Extra variables used during extra transformations.
-    var $footnotes = array();
-
-    var $footnotes_ordered = array();
-
-    var $footnotes_ref_count = array();
-
-    var $footnotes_numbers = array();
-
-    var $abbr_desciptions = array();
-
-    var $abbr_word_re = '';
-
-    # Give the current footnote number.
-    var $footnote_counter = 1;
-
-    function setup()
-    {
-        #
-        # Setting up Extra-specific variables.
-        #
-        parent::setup();
-
-        $this->footnotes           = array();
-        $this->footnotes_ordered   = array();
-        $this->footnotes_ref_count = array();
-        $this->footnotes_numbers   = array();
-        $this->abbr_desciptions    = array();
-        $this->abbr_word_re        = '';
-        $this->footnote_counter    = 1;
-
-        foreach ($this->predef_abbr as $abbr_word => $abbr_desc) {
-            if ($this->abbr_word_re) {
-                $this->abbr_word_re .= '|';
-            }
-            $this->abbr_word_re .= preg_quote($abbr_word);
-            $this->abbr_desciptions[$abbr_word] = trim($abbr_desc);
-        }
-    }
-
-    function teardown()
-    {
-        #
-        # Clearing Extra-specific variables.
-        #
-        $this->footnotes           = array();
-        $this->footnotes_ordered   = array();
-        $this->footnotes_ref_count = array();
-        $this->footnotes_numbers   = array();
-        $this->abbr_desciptions    = array();
-        $this->abbr_word_re        = '';
-
-        parent::teardown();
-    }
-
-
-    ### Extra Attribute Parser ###
-
-    # Expression to use to catch attributes (includes the braces)
-    var $id_class_attr_catch_re = '\{((?:[ ]*[#.][-_:a-zA-Z0-9]+){1,})[ ]*\}';
-
-    # Expression to use when parsing in a context when no capture is desired
-    var $id_class_attr_nocatch_re = '\{(?:[ ]*[#.][-_:a-zA-Z0-9]+){1,}[ ]*\}';
-
-    function doExtraAttributes($tag_name, $attr)
-    {
-        #
-        # Parse attributes caught by the $this->id_class_attr_catch_re expression
-        # and return the HTML-formatted list of attributes.
-        #
-        # Currently supported attributes are .class and #id.
-        #
-        if (empty($attr)) {
-            return "";
-        }
-
-        # Split on components
-        preg_match_all('/[#.][-_:a-zA-Z0-9]+/', $attr, $matches);
-        $elements = $matches[0];
-
-        # handle classes and ids (only first id taken into account)
-        $classes = array();
-        $id      = false;
-        foreach ($elements as $element) {
-            if ($element{0} == '.') {
-                $classes[] = substr($element, 1);
-            } else if ($element{0} == '#') {
-                if ($id === false) {
-                    $id = substr($element, 1);
-                }
-            }
-        }
-
-        # compose attributes as string
-        $attr_str = "";
-        if (!empty($id)) {
-            $attr_str .= ' id="' . $id . '"';
-        }
-        if (!empty($classes)) {
-            $attr_str .= ' class="' . implode(" ", $classes) . '"';
-        }
-        return $attr_str;
-    }
-
-    function stripLinkDefinitions($text)
-    {
-        #
-        # Strips link definitions from text, stores the URLs and titles in
-        # hash references.
-        #
-        $less_than_tab = $this->tab_width - 1;
-
-        # Link defs are in the form: ^[id]: url "optional title"
-        $text = preg_replace_callback(
-            '{
+	# Predefined abbreviations.
+	var $predef_abbr = array();
+
+	### Parser Implementation ###
+
+	function __construct()
+	{
+		#
+		# Constructor function. Initialize the parser object.
+		#
+		# Add extra escapable characters before parent constructor
+		# initialize the table.
+		$this->escape_chars .= ':|';
+
+		# Insert extra document, block, and span transformations.
+		# Parent constructor will do the sorting.
+		$this->document_gamut += array(
+			"doFencedCodeBlocks" => 5,
+			"stripFootnotes"     => 15,
+			"stripAbbreviations" => 25,
+			"appendFootnotes"    => 50,
+		);
+		$this->block_gamut += array(
+			"doFencedCodeBlocks" => 5,
+			"doTables"           => 15,
+			"doDefLists"         => 45,
+		);
+		$this->span_gamut += array(
+			"doFootnotes"     => 5,
+			"doAbbreviations" => 70,
+		);
+
+		parent::__construct();
+	}
+
+	# Extra variables used during extra transformations.
+	var $footnotes = array();
+
+	var $footnotes_ordered = array();
+
+	var $footnotes_ref_count = array();
+
+	var $footnotes_numbers = array();
+
+	var $abbr_desciptions = array();
+
+	var $abbr_word_re = '';
+
+	# Give the current footnote number.
+	var $footnote_counter = 1;
+
+	function setup()
+	{
+		#
+		# Setting up Extra-specific variables.
+		#
+		parent::setup();
+
+		$this->footnotes           = array();
+		$this->footnotes_ordered   = array();
+		$this->footnotes_ref_count = array();
+		$this->footnotes_numbers   = array();
+		$this->abbr_desciptions    = array();
+		$this->abbr_word_re        = '';
+		$this->footnote_counter    = 1;
+
+		foreach ($this->predef_abbr as $abbr_word => $abbr_desc) {
+			if ($this->abbr_word_re) {
+				$this->abbr_word_re .= '|';
+			}
+			$this->abbr_word_re .= preg_quote($abbr_word);
+			$this->abbr_desciptions[$abbr_word] = trim($abbr_desc);
+		}
+	}
+
+	function teardown()
+	{
+		#
+		# Clearing Extra-specific variables.
+		#
+		$this->footnotes           = array();
+		$this->footnotes_ordered   = array();
+		$this->footnotes_ref_count = array();
+		$this->footnotes_numbers   = array();
+		$this->abbr_desciptions    = array();
+		$this->abbr_word_re        = '';
+
+		parent::teardown();
+	}
+
+
+	### Extra Attribute Parser ###
+
+	# Expression to use to catch attributes (includes the braces)
+	var $id_class_attr_catch_re = '\{((?:[ ]*[#.][-_:a-zA-Z0-9]+){1,})[ ]*\}';
+
+	# Expression to use when parsing in a context when no capture is desired
+	var $id_class_attr_nocatch_re = '\{(?:[ ]*[#.][-_:a-zA-Z0-9]+){1,}[ ]*\}';
+
+	function doExtraAttributes($tag_name, $attr)
+	{
+		#
+		# Parse attributes caught by the $this->id_class_attr_catch_re expression
+		# and return the HTML-formatted list of attributes.
+		#
+		# Currently supported attributes are .class and #id.
+		#
+		if (empty($attr)) {
+			return "";
+		}
+
+		# Split on components
+		preg_match_all('/[#.][-_:a-zA-Z0-9]+/', $attr, $matches);
+		$elements = $matches[0];
+
+		# handle classes and ids (only first id taken into account)
+		$classes = array();
+		$id      = false;
+		foreach ($elements as $element) {
+			if ($element{0} == '.') {
+				$classes[] = substr($element, 1);
+			} else if ($element{0} == '#') {
+				if ($id === false) {
+					$id = substr($element, 1);
+				}
+			}
+		}
+
+		# compose attributes as string
+		$attr_str = "";
+		if (!empty($id)) {
+			$attr_str .= ' id="' . $id . '"';
+		}
+		if (!empty($classes)) {
+			$attr_str .= ' class="' . implode(" ", $classes) . '"';
+		}
+		return $attr_str;
+	}
+
+	function stripLinkDefinitions($text)
+	{
+		#
+		# Strips link definitions from text, stores the URLs and titles in
+		# hash references.
+		#
+		$less_than_tab = $this->tab_width - 1;
+
+		# Link defs are in the form: ^[id]: url "optional title"
+		$text = preg_replace_callback(
+			'{
 							^[ ]{0,' . $less_than_tab . '}\[(.+)\][ ]?:	# id = $1
 							  [ ]*
 							  \n?				# maybe *one* newline
@@ -2026,117 +2026,117 @@ 
 					(?:[ ]* ' . $this->id_class_attr_catch_re . ' )?  # $5 = extra id & class attr
 							(?:\n+|\Z)
 			}xm',
-            array(&$this, '_stripLinkDefinitions_callback'),
-            $text
-        );
-        return $text;
-    }
-
-    function _stripLinkDefinitions_callback($matches)
-    {
-        $link_id                  = strtolower($matches[1]);
-        $url                      = $matches[2] == '' ? $matches[3] : $matches[2];
-        $this->urls[$link_id]     = $url;
-        $this->titles[$link_id]   =& $matches[4];
-        $this->ref_attr[$link_id] = $this->doExtraAttributes("", $dummy =& $matches[5]);
-        return ''; # String that will replace the block
-    }
-
-
-    ### HTML Block Parser ###
-
-    # Tags that are always treated as block tags:
-    var $block_tags_re = 'p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|address|form|fieldset|iframe|hr|legend|article|section|nav|aside|hgroup|header|footer|figcaption';
-
-    # Tags treated as block tags only if the opening tag is alone on its line:
-    var $context_block_tags_re = 'script|noscript|ins|del|iframe|object|source|track|param|math|svg|canvas|audio|video';
-
-    # Tags where markdown="1" default to span mode:
-    var $contain_span_tags_re = 'p|h[1-6]|li|dd|dt|td|th|legend|address';
-
-    # Tags which must not have their contents modified, no matter where
-    # they appear:
-    var $clean_tags_re = 'script|math|svg';
-
-    # Tags that do not need to be closed.
-    var $auto_close_tags_re = 'hr|img|param|source|track';
-
-    function hashHTMLBlocks($text)
-    {
-        #
-        # Hashify HTML Blocks and "clean tags".
-        #
-        # We only want to do this for block-level HTML tags, such as headers,
-        # lists, and tables. That's because we still want to wrap <p>s around
-        # "paragraphs" that are wrapped in non-block-level tags, such as anchors,
-        # phrase emphasis, and spans. The list of tags we're looking for is
-        # hard-coded.
-        #
-        # This works by calling _HashHTMLBlocks_InMarkdown, which then calls
-        # _HashHTMLBlocks_InHTML when it encounter block tags. When the markdown="1"
-        # attribute is found within a tag, _HashHTMLBlocks_InHTML calls back
-        #  _HashHTMLBlocks_InMarkdown to handle the Markdown syntax within the tag.
-        # These two functions are calling each other. It's recursive!
-        #
-        if ($this->no_markup) {
-            return $text;
-        }
-
-        #
-        # Call the HTML-in-Markdown hasher.
-        #
-        list($text,) = $this->_hashHTMLBlocks_inMarkdown($text);
-
-        return $text;
-    }
-
-    function _hashHTMLBlocks_inMarkdown(
-        $text,
-        $indent = 0,
-        $enclosing_tag_re = '',
-        $span = false
-    ) {
-        #
-        # Parse markdown text, calling _HashHTMLBlocks_InHTML for block tags.
-        #
-        # *   $indent is the number of space to be ignored when checking for code
-        #     blocks. This is important because if we don't take the indent into
-        #     account, something like this (which looks right) won't work as expected:
-        #
-        #     <div>
-        #         <div markdown="1">
-        #         Hello World.  <-- Is this a Markdown code block or text?
-        #         </div>  <-- Is this a Markdown code block or a real tag?
-        #     <div>
-        #
-        #     If you don't like this, just don't indent the tag on which
-        #     you apply the markdown="1" attribute.
-        #
-        # *   If $enclosing_tag_re is not empty, stops at the first unmatched closing
-        #     tag with that name. Nested tags supported.
-        #
-        # *   If $span is true, text inside must treated as span. So any double
-        #     newline will be replaced by a single newline so that it does not create
-        #     paragraphs.
-        #
-        # Returns an array of that form: ( processed text , remaining text )
-        #
-        if ($text === '') {
-            return array('', '');
-        }
-
-        # Regex to check for the presense of newlines around a block tag.
-        $newline_before_re = '/(?:^\n?|\n\n)*$/';
-        $newline_after_re  =
-            '{
+			array(&$this, '_stripLinkDefinitions_callback'),
+			$text
+		);
+		return $text;
+	}
+
+	function _stripLinkDefinitions_callback($matches)
+	{
+		$link_id                  = strtolower($matches[1]);
+		$url                      = $matches[2] == '' ? $matches[3] : $matches[2];
+		$this->urls[$link_id]     = $url;
+		$this->titles[$link_id]   =& $matches[4];
+		$this->ref_attr[$link_id] = $this->doExtraAttributes("", $dummy =& $matches[5]);
+		return ''; # String that will replace the block
+	}
+
+
+	### HTML Block Parser ###
+
+	# Tags that are always treated as block tags:
+	var $block_tags_re = 'p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|address|form|fieldset|iframe|hr|legend|article|section|nav|aside|hgroup|header|footer|figcaption';
+
+	# Tags treated as block tags only if the opening tag is alone on its line:
+	var $context_block_tags_re = 'script|noscript|ins|del|iframe|object|source|track|param|math|svg|canvas|audio|video';
+
+	# Tags where markdown="1" default to span mode:
+	var $contain_span_tags_re = 'p|h[1-6]|li|dd|dt|td|th|legend|address';
+
+	# Tags which must not have their contents modified, no matter where
+	# they appear:
+	var $clean_tags_re = 'script|math|svg';
+
+	# Tags that do not need to be closed.
+	var $auto_close_tags_re = 'hr|img|param|source|track';
+
+	function hashHTMLBlocks($text)
+	{
+		#
+		# Hashify HTML Blocks and "clean tags".
+		#
+		# We only want to do this for block-level HTML tags, such as headers,
+		# lists, and tables. That's because we still want to wrap <p>s around
+		# "paragraphs" that are wrapped in non-block-level tags, such as anchors,
+		# phrase emphasis, and spans. The list of tags we're looking for is
+		# hard-coded.
+		#
+		# This works by calling _HashHTMLBlocks_InMarkdown, which then calls
+		# _HashHTMLBlocks_InHTML when it encounter block tags. When the markdown="1"
+		# attribute is found within a tag, _HashHTMLBlocks_InHTML calls back
+		#  _HashHTMLBlocks_InMarkdown to handle the Markdown syntax within the tag.
+		# These two functions are calling each other. It's recursive!
+		#
+		if ($this->no_markup) {
+			return $text;
+		}
+
+		#
+		# Call the HTML-in-Markdown hasher.
+		#
+		list($text,) = $this->_hashHTMLBlocks_inMarkdown($text);
+
+		return $text;
+	}
+
+	function _hashHTMLBlocks_inMarkdown(
+		$text,
+		$indent = 0,
+		$enclosing_tag_re = '',
+		$span = false
+	) {
+		#
+		# Parse markdown text, calling _HashHTMLBlocks_InHTML for block tags.
+		#
+		# *   $indent is the number of space to be ignored when checking for code
+		#     blocks. This is important because if we don't take the indent into
+		#     account, something like this (which looks right) won't work as expected:
+		#
+		#     <div>
+		#         <div markdown="1">
+		#         Hello World.  <-- Is this a Markdown code block or text?
+		#         </div>  <-- Is this a Markdown code block or a real tag?
+		#     <div>
+		#
+		#     If you don't like this, just don't indent the tag on which
+		#     you apply the markdown="1" attribute.
+		#
+		# *   If $enclosing_tag_re is not empty, stops at the first unmatched closing
+		#     tag with that name. Nested tags supported.
+		#
+		# *   If $span is true, text inside must treated as span. So any double
+		#     newline will be replaced by a single newline so that it does not create
+		#     paragraphs.
+		#
+		# Returns an array of that form: ( processed text , remaining text )
+		#
+		if ($text === '') {
+			return array('', '');
+		}
+
+		# Regex to check for the presense of newlines around a block tag.
+		$newline_before_re = '/(?:^\n?|\n\n)*$/';
+		$newline_after_re  =
+			'{
 				^						# Start of text following the tag.
 				(?>[ ]*<!--.*?-->)?		# Optional comment.
 				[ ]*\n					# Must be followed by newline.
 			}xs';
 
-        # Regex to match any tag.
-        $block_tag_re =
-            '{
+		# Regex to match any tag.
+		$block_tag_re =
+			'{
 				(					# $2: Capture whole tag.
 					</?					# Any opening or closing tag.
 						(?>				# Tag name.
@@ -2187,177 +2187,177 @@ 
 				)
 			}xs';
 
-        $depth  = 0; # Current depth inside the tag tree.
-        $parsed = ""; # Parsed text that will be returned.
-
-        #
-        # Loop through every tag until we find the closing tag of the parent
-        # or loop until reaching the end of text if no parent tag specified.
-        #
-        do {
-            #
-            # Split the text using the first $tag_match pattern found.
-            # Text before  pattern will be first in the array, text after
-            # pattern will be at the end, and between will be any catches made
-            # by the pattern.
-            #
-            $parts = preg_split(
-                $block_tag_re,
-                $text,
-                2,
-                PREG_SPLIT_DELIM_CAPTURE
-            );
-
-            # If in Markdown span mode, add a empty-string span-level hash
-            # after each newline to prevent triggering any block element.
-            if ($span) {
-                $void     = $this->hashPart("", ':');
-                $newline  = "$void\n";
-                $parts[0] = $void . str_replace("\n", $newline, $parts[0]) . $void;
-            }
-
-            $parsed .= $parts[0]; # Text before current tag.
-
-            # If end of $text has been reached. Stop loop.
-            if (count($parts) < 3) {
-                $text = "";
-                break;
-            }
-
-            $tag    = $parts[1]; # Tag to handle.
-            $text   = $parts[2]; # Remaining text after current tag.
-            $tag_re = preg_quote($tag); # For use in a regular expression.
-
-            #
-            # Check for: Code span marker
-            #
-            if ($tag{0} == "`") {
-                # Find corresponding end marker.
-                $tag_re = preg_quote($tag);
-                if (preg_match(
-                    '{^(?>.+?|\n(?!\n))*?(?<!`)' . $tag_re . '(?!`)}',
-                    $text,
-                    $matches
-                )) {
-                    # End marker found: pass text unchanged until marker.
-                    $parsed .= $tag . $matches[0];
-                    $text = substr($text, strlen($matches[0]));
-                } else {
-                    # Unmatched marker: just skip it.
-                    $parsed .= $tag;
-                }
-            }
-            #
-            # Check for: Fenced code block marker.
-            #
-            else if (preg_match('{^\n?([ ]{0,' . ($indent + 3) . '})(~+)}', $tag, $capture)) {
-                # Fenced code block marker: find matching end marker.
-                $fence_indent = strlen($capture[1]); # use captured indent in re
-                $fence_re     = $capture[2]; # use captured fence in re
-                if (preg_match(
-                    '{^(?>.*\n)*?[ ]{' . ($fence_indent) . '}' . $fence_re . '[ ]*(?:\n|$)}',
-                    $text,
-                    $matches
-                )) {
-                    # End marker found: pass text unchanged until marker.
-                    $parsed .= $tag . $matches[0];
-                    $text = substr($text, strlen($matches[0]));
-                } else {
-                    # No end marker: just skip it.
-                    $parsed .= $tag;
-                }
-            }
-            #
-            # Check for: Indented code block.
-            #
-            else if ($tag{0} == "\n" || $tag{0} == " ") {
-                # Indented code block: pass it unchanged, will be handled
-                # later.
-                $parsed .= $tag;
-            }
-            #
-            # Check for: Opening Block level tag or
-            #            Opening Context Block tag (like ins and del)
-            #               used as a block tag (tag is alone on it's line).
-            #
-            else if (preg_match('{^<(?:' . $this->block_tags_re . ')\b}', $tag) ||
-                     (preg_match('{^<(?:' . $this->context_block_tags_re . ')\b}', $tag) &&
-                      preg_match($newline_before_re, $parsed) &&
-                      preg_match($newline_after_re, $text))
-            ) {
-                # Need to parse tag and following text using the HTML parser.
-                list($block_text, $text) =
-                    $this->_hashHTMLBlocks_inHTML($tag . $text, "hashBlock", true);
-
-                # Make sure it stays outside of any paragraph by adding newlines.
-                $parsed .= "\n\n$block_text\n\n";
-            }
-            #
-            # Check for: Clean tag (like script, math)
-            #            HTML Comments, processing instructions.
-            #
-            else if (preg_match('{^<(?:' . $this->clean_tags_re . ')\b}', $tag) ||
-                     $tag{1} == '!' || $tag{1} == '?'
-            ) {
-                # Need to parse tag and following text using the HTML parser.
-                # (don't check for markdown attribute)
-                list($block_text, $text) =
-                    $this->_hashHTMLBlocks_inHTML($tag . $text, "hashClean", false);
-
-                $parsed .= $block_text;
-            }
-            #
-            # Check for: Tag with same name as enclosing tag.
-            #
-            else if ($enclosing_tag_re !== '' &&
-                     # Same name as enclosing tag.
-                     preg_match('{^</?(?:' . $enclosing_tag_re . ')\b}', $tag)
-            ) {
-                #
-                # Increase/decrease nested tag count.
-                #
-                if ($tag{1} == '/') {
-                    $depth --;
-                } else if ($tag{strlen($tag) - 2} != '/') {
-                    $depth ++;
-                }
-
-                if ($depth < 0) {
-                    #
-                    # Going out of parent element. Clean up and break so we
-                    # return to the calling function.
-                    #
-                    $text = $tag . $text;
-                    break;
-                }
-
-                $parsed .= $tag;
-            } else {
-                $parsed .= $tag;
-            }
-        } while ($depth >= 0);
-
-        return array($parsed, $text);
-    }
-
-    function _hashHTMLBlocks_inHTML($text, $hash_method, $md_attr)
-    {
-        #
-        # Parse HTML, calling _HashHTMLBlocks_InMarkdown for block tags.
-        #
-        # *   Calls $hash_method to convert any blocks.
-        # *   Stops when the first opening tag closes.
-        # *   $md_attr indicate if the use of the `markdown="1"` attribute is allowed.
-        #     (it is not inside clean tags)
-        #
-        # Returns an array of that form: ( processed text , remaining text )
-        #
-        if ($text === '') {
-            return array('', '');
-        }
-
-        # Regex to match `markdown` attribute inside of a tag.
-        $markdown_attr_re = '
+		$depth  = 0; # Current depth inside the tag tree.
+		$parsed = ""; # Parsed text that will be returned.
+
+		#
+		# Loop through every tag until we find the closing tag of the parent
+		# or loop until reaching the end of text if no parent tag specified.
+		#
+		do {
+			#
+			# Split the text using the first $tag_match pattern found.
+			# Text before  pattern will be first in the array, text after
+			# pattern will be at the end, and between will be any catches made
+			# by the pattern.
+			#
+			$parts = preg_split(
+				$block_tag_re,
+				$text,
+				2,
+				PREG_SPLIT_DELIM_CAPTURE
+			);
+
+			# If in Markdown span mode, add a empty-string span-level hash
+			# after each newline to prevent triggering any block element.
+			if ($span) {
+				$void     = $this->hashPart("", ':');
+				$newline  = "$void\n";
+				$parts[0] = $void . str_replace("\n", $newline, $parts[0]) . $void;
+			}
+
+			$parsed .= $parts[0]; # Text before current tag.
+
+			# If end of $text has been reached. Stop loop.
+			if (count($parts) < 3) {
+				$text = "";
+				break;
+			}
+
+			$tag    = $parts[1]; # Tag to handle.
+			$text   = $parts[2]; # Remaining text after current tag.
+			$tag_re = preg_quote($tag); # For use in a regular expression.
+
+			#
+			# Check for: Code span marker
+			#
+			if ($tag{0} == "`") {
+				# Find corresponding end marker.
+				$tag_re = preg_quote($tag);
+				if (preg_match(
+					'{^(?>.+?|\n(?!\n))*?(?<!`)' . $tag_re . '(?!`)}',
+					$text,
+					$matches
+				)) {
+					# End marker found: pass text unchanged until marker.
+					$parsed .= $tag . $matches[0];
+					$text = substr($text, strlen($matches[0]));
+				} else {
+					# Unmatched marker: just skip it.
+					$parsed .= $tag;
+				}
+			}
+			#
+			# Check for: Fenced code block marker.
+			#
+			else if (preg_match('{^\n?([ ]{0,' . ($indent + 3) . '})(~+)}', $tag, $capture)) {
+				# Fenced code block marker: find matching end marker.
+				$fence_indent = strlen($capture[1]); # use captured indent in re
+				$fence_re     = $capture[2]; # use captured fence in re
+				if (preg_match(
+					'{^(?>.*\n)*?[ ]{' . ($fence_indent) . '}' . $fence_re . '[ ]*(?:\n|$)}',
+					$text,
+					$matches
+				)) {
+					# End marker found: pass text unchanged until marker.
+					$parsed .= $tag . $matches[0];
+					$text = substr($text, strlen($matches[0]));
+				} else {
+					# No end marker: just skip it.
+					$parsed .= $tag;
+				}
+			}
+			#
+			# Check for: Indented code block.
+			#
+			else if ($tag{0} == "\n" || $tag{0} == " ") {
+				# Indented code block: pass it unchanged, will be handled
+				# later.
+				$parsed .= $tag;
+			}
+			#
+			# Check for: Opening Block level tag or
+			#            Opening Context Block tag (like ins and del)
+			#               used as a block tag (tag is alone on it's line).
+			#
+			else if (preg_match('{^<(?:' . $this->block_tags_re . ')\b}', $tag) ||
+					 (preg_match('{^<(?:' . $this->context_block_tags_re . ')\b}', $tag) &&
+					  preg_match($newline_before_re, $parsed) &&
+					  preg_match($newline_after_re, $text))
+			) {
+				# Need to parse tag and following text using the HTML parser.
+				list($block_text, $text) =
+					$this->_hashHTMLBlocks_inHTML($tag . $text, "hashBlock", true);
+
+				# Make sure it stays outside of any paragraph by adding newlines.
+				$parsed .= "\n\n$block_text\n\n";
+			}
+			#
+			# Check for: Clean tag (like script, math)
+			#            HTML Comments, processing instructions.
+			#
+			else if (preg_match('{^<(?:' . $this->clean_tags_re . ')\b}', $tag) ||
+					 $tag{1} == '!' || $tag{1} == '?'
+			) {
+				# Need to parse tag and following text using the HTML parser.
+				# (don't check for markdown attribute)
+				list($block_text, $text) =
+					$this->_hashHTMLBlocks_inHTML($tag . $text, "hashClean", false);
+
+				$parsed .= $block_text;
+			}
+			#
+			# Check for: Tag with same name as enclosing tag.
+			#
+			else if ($enclosing_tag_re !== '' &&
+					 # Same name as enclosing tag.
+					 preg_match('{^</?(?:' . $enclosing_tag_re . ')\b}', $tag)
+			) {
+				#
+				# Increase/decrease nested tag count.
+				#
+				if ($tag{1} == '/') {
+					$depth --;
+				} else if ($tag{strlen($tag) - 2} != '/') {
+					$depth ++;
+				}
+
+				if ($depth < 0) {
+					#
+					# Going out of parent element. Clean up and break so we
+					# return to the calling function.
+					#
+					$text = $tag . $text;
+					break;
+				}
+
+				$parsed .= $tag;
+			} else {
+				$parsed .= $tag;
+			}
+		} while ($depth >= 0);
+
+		return array($parsed, $text);
+	}
+
+	function _hashHTMLBlocks_inHTML($text, $hash_method, $md_attr)
+	{
+		#
+		# Parse HTML, calling _HashHTMLBlocks_InMarkdown for block tags.
+		#
+		# *   Calls $hash_method to convert any blocks.
+		# *   Stops when the first opening tag closes.
+		# *   $md_attr indicate if the use of the `markdown="1"` attribute is allowed.
+		#     (it is not inside clean tags)
+		#
+		# Returns an array of that form: ( processed text , remaining text )
+		#
+		if ($text === '') {
+			return array('', '');
+		}
+
+		# Regex to match `markdown` attribute inside of a tag.
+		$markdown_attr_re = '
 			{
 				\s*			# Eat whitespace before the `markdown` attribute
 				markdown
@@ -2372,8 +2372,8 @@ 
 				()				# $4: make $3 always defined (avoid warnings)
 			}xs';
 
-        # Regex to match any tag.
-        $tag_re = '{
+		# Regex to match any tag.
+		$tag_re = '{
 				(					# $2: Capture whole tag.
 					</?					# Any opening or closing tag.
 						[\w:$]+			# Tag name.
@@ -2395,169 +2395,169 @@ 
 				)
 			}xs';
 
-        $original_text = $text; # Save original text in case of faliure.
-
-        $depth      = 0; # Current depth inside the tag tree.
-        $block_text = ""; # Temporary text holder for current text.
-        $parsed     = ""; # Parsed text that will be returned.
-
-        #
-        # Get the name of the starting tag.
-        # (This pattern makes $base_tag_name_re safe without quoting.)
-        #
-        if (preg_match('/^<([\w:$]*)\b/', $text, $matches)) {
-            $base_tag_name_re = $matches[1];
-        }
-
-        #
-        # Loop through every tag until we find the corresponding closing tag.
-        #
-        do {
-            #
-            # Split the text using the first $tag_match pattern found.
-            # Text before  pattern will be first in the array, text after
-            # pattern will be at the end, and between will be any catches made
-            # by the pattern.
-            #
-            $parts = preg_split($tag_re, $text, 2, PREG_SPLIT_DELIM_CAPTURE);
-
-            if (count($parts) < 3) {
-                #
-                # End of $text reached with unbalenced tag(s).
-                # In that case, we return original text unchanged and pass the
-                # first character as filtered to prevent an infinite loop in the
-                # parent function.
-                #
-                return array($original_text{0}, substr($original_text, 1));
-            }
-
-            $block_text .= $parts[0]; # Text before current tag.
-            $tag  = $parts[1]; # Tag to handle.
-            $text = $parts[2]; # Remaining text after current tag.
-
-            #
-            # Check for: Auto-close tag (like <hr/>)
-            #			 Comments and Processing Instructions.
-            #
-            if (preg_match('{^</?(?:' . $this->auto_close_tags_re . ')\b}', $tag) ||
-                $tag{1} == '!' || $tag{1} == '?'
-            ) {
-                # Just add the tag to the block as if it was text.
-                $block_text .= $tag;
-            } else {
-                #
-                # Increase/decrease nested tag count. Only do so if
-                # the tag's name match base tag's.
-                #
-                if (preg_match('{^</?' . $base_tag_name_re . '\b}', $tag)) {
-                    if ($tag{1} == '/') {
-                        $depth --;
-                    } else if ($tag{strlen($tag) - 2} != '/') {
-                        $depth ++;
-                    }
-                }
-
-                #
-                # Check for `markdown="1"` attribute and handle it.
-                #
-                if ($md_attr &&
-                    preg_match($markdown_attr_re, $tag, $attr_m) &&
-                    preg_match('/^1|block|span$/', $attr_m[2] . $attr_m[3])
-                ) {
-                    # Remove `markdown` attribute from opening tag.
-                    $tag = preg_replace($markdown_attr_re, '', $tag);
-
-                    # Check if text inside this tag must be parsed in span mode.
-                    $this->mode = $attr_m[2] . $attr_m[3];
-                    $span_mode  = $this->mode == 'span' || $this->mode != 'block' &&
-                                                           preg_match(
-                                                               '{^<(?:' . $this->contain_span_tags_re . ')\b}',
-                                                               $tag
-                                                           );
-
-                    # Calculate indent before tag.
-                    if (preg_match('/(?:^|\n)( *?)(?! ).*?$/', $block_text, $matches)) {
-                        $strlen = $this->utf8_strlen;
-                        $indent = $strlen($matches[1], 'UTF-8');
-                    } else {
-                        $indent = 0;
-                    }
-
-                    # End preceding block with this tag.
-                    $block_text .= $tag;
-                    $parsed .= $this->$hash_method($block_text);
-
-                    # Get enclosing tag name for the ParseMarkdown function.
-                    # (This pattern makes $tag_name_re safe without quoting.)
-                    preg_match('/^<([\w:$]*)\b/', $tag, $matches);
-                    $tag_name_re = $matches[1];
-
-                    # Parse the content using the HTML-in-Markdown parser.
-                    list ($block_text, $text)
-                        = $this->_hashHTMLBlocks_inMarkdown(
-                        $text,
-                        $indent,
-                        $tag_name_re,
-                        $span_mode
-                    );
-
-                    # Outdent markdown text.
-                    if ($indent > 0) {
-                        $block_text = preg_replace(
-                            "/^[ ]{1,$indent}/m",
-                            "",
-                            $block_text
-                        );
-                    }
-
-                    # Append tag content to parsed text.
-                    if (!$span_mode) {
-                        $parsed .= "\n\n$block_text\n\n";
-                    } else {
-                        $parsed .= "$block_text";
-                    }
-
-                    # Start over with a new block.
-                    $block_text = "";
-                } else {
-                    $block_text .= $tag;
-                }
-            }
-        } while ($depth > 0);
-
-        #
-        # Hash last block text that wasn't processed inside the loop.
-        #
-        $parsed .= $this->$hash_method($block_text);
-
-        return array($parsed, $text);
-    }
-
-    function hashClean($text)
-    {
-        #
-        # Called whenever a tag must be hashed when a function inserts a "clean" tag
-        # in $text, it passes through this function and is automaticaly escaped,
-        # blocking invalid nested overlap.
-        #
-        return $this->hashPart($text, 'C');
-    }
-
-    function doAnchors($text)
-    {
-        #
-        # Turn Markdown link shortcuts into XHTML <a> tags.
-        #
-        if ($this->in_anchor) {
-            return $text;
-        }
-        $this->in_anchor = true;
-
-        #
-        # First, handle reference-style links: [link text] [id]
-        #
-        $text = preg_replace_callback(
-            '{
+		$original_text = $text; # Save original text in case of faliure.
+
+		$depth      = 0; # Current depth inside the tag tree.
+		$block_text = ""; # Temporary text holder for current text.
+		$parsed     = ""; # Parsed text that will be returned.
+
+		#
+		# Get the name of the starting tag.
+		# (This pattern makes $base_tag_name_re safe without quoting.)
+		#
+		if (preg_match('/^<([\w:$]*)\b/', $text, $matches)) {
+			$base_tag_name_re = $matches[1];
+		}
+
+		#
+		# Loop through every tag until we find the corresponding closing tag.
+		#
+		do {
+			#
+			# Split the text using the first $tag_match pattern found.
+			# Text before  pattern will be first in the array, text after
+			# pattern will be at the end, and between will be any catches made
+			# by the pattern.
+			#
+			$parts = preg_split($tag_re, $text, 2, PREG_SPLIT_DELIM_CAPTURE);
+
+			if (count($parts) < 3) {
+				#
+				# End of $text reached with unbalenced tag(s).
+				# In that case, we return original text unchanged and pass the
+				# first character as filtered to prevent an infinite loop in the
+				# parent function.
+				#
+				return array($original_text{0}, substr($original_text, 1));
+			}
+
+			$block_text .= $parts[0]; # Text before current tag.
+			$tag  = $parts[1]; # Tag to handle.
+			$text = $parts[2]; # Remaining text after current tag.
+
+			#
+			# Check for: Auto-close tag (like <hr/>)
+			#			 Comments and Processing Instructions.
+			#
+			if (preg_match('{^</?(?:' . $this->auto_close_tags_re . ')\b}', $tag) ||
+				$tag{1} == '!' || $tag{1} == '?'
+			) {
+				# Just add the tag to the block as if it was text.
+				$block_text .= $tag;
+			} else {
+				#
+				# Increase/decrease nested tag count. Only do so if
+				# the tag's name match base tag's.
+				#
+				if (preg_match('{^</?' . $base_tag_name_re . '\b}', $tag)) {
+					if ($tag{1} == '/') {
+						$depth --;
+					} else if ($tag{strlen($tag) - 2} != '/') {
+						$depth ++;
+					}
+				}
+
+				#
+				# Check for `markdown="1"` attribute and handle it.
+				#
+				if ($md_attr &&
+					preg_match($markdown_attr_re, $tag, $attr_m) &&
+					preg_match('/^1|block|span$/', $attr_m[2] . $attr_m[3])
+				) {
+					# Remove `markdown` attribute from opening tag.
+					$tag = preg_replace($markdown_attr_re, '', $tag);
+
+					# Check if text inside this tag must be parsed in span mode.
+					$this->mode = $attr_m[2] . $attr_m[3];
+					$span_mode  = $this->mode == 'span' || $this->mode != 'block' &&
+														   preg_match(
+															   '{^<(?:' . $this->contain_span_tags_re . ')\b}',
+															   $tag
+														   );
+
+					# Calculate indent before tag.
+					if (preg_match('/(?:^|\n)( *?)(?! ).*?$/', $block_text, $matches)) {
+						$strlen = $this->utf8_strlen;
+						$indent = $strlen($matches[1], 'UTF-8');
+					} else {
+						$indent = 0;
+					}
+
+					# End preceding block with this tag.
+					$block_text .= $tag;
+					$parsed .= $this->$hash_method($block_text);
+
+					# Get enclosing tag name for the ParseMarkdown function.
+					# (This pattern makes $tag_name_re safe without quoting.)
+					preg_match('/^<([\w:$]*)\b/', $tag, $matches);
+					$tag_name_re = $matches[1];
+
+					# Parse the content using the HTML-in-Markdown parser.
+					list ($block_text, $text)
+						= $this->_hashHTMLBlocks_inMarkdown(
+						$text,
+						$indent,
+						$tag_name_re,
+						$span_mode
+					);
+
+					# Outdent markdown text.
+					if ($indent > 0) {
+						$block_text = preg_replace(
+							"/^[ ]{1,$indent}/m",
+							"",
+							$block_text
+						);
+					}
+
+					# Append tag content to parsed text.
+					if (!$span_mode) {
+						$parsed .= "\n\n$block_text\n\n";
+					} else {
+						$parsed .= "$block_text";
+					}
+
+					# Start over with a new block.
+					$block_text = "";
+				} else {
+					$block_text .= $tag;
+				}
+			}
+		} while ($depth > 0);
+
+		#
+		# Hash last block text that wasn't processed inside the loop.
+		#
+		$parsed .= $this->$hash_method($block_text);
+
+		return array($parsed, $text);
+	}
+
+	function hashClean($text)
+	{
+		#
+		# Called whenever a tag must be hashed when a function inserts a "clean" tag
+		# in $text, it passes through this function and is automaticaly escaped,
+		# blocking invalid nested overlap.
+		#
+		return $this->hashPart($text, 'C');
+	}
+
+	function doAnchors($text)
+	{
+		#
+		# Turn Markdown link shortcuts into XHTML <a> tags.
+		#
+		if ($this->in_anchor) {
+			return $text;
+		}
+		$this->in_anchor = true;
+
+		#
+		# First, handle reference-style links: [link text] [id]
+		#
+		$text = preg_replace_callback(
+			'{
 			(					# wrap whole match in $1
 			  \[
 				(' . $this->nested_brackets_re . ')	# link text = $2
@@ -2571,15 +2571,15 @@ 
 			  \]
 			)
 			}xs',
-            array(&$this, '_doAnchors_reference_callback'),
-            $text
-        );
-
-        #
-        # Next, inline-style links: [link text](url "optional title")
-        #
-        $text = preg_replace_callback(
-            '{
+			array(&$this, '_doAnchors_reference_callback'),
+			$text
+		);
+
+		#
+		# Next, inline-style links: [link text](url "optional title")
+		#
+		$text = preg_replace_callback(
+			'{
 			(				# wrap whole match in $1
 			  \[
 				(' . $this->nested_brackets_re . ')	# link text = $2
@@ -2602,102 +2602,102 @@ 
 			  (?:[ ]? ' . $this->id_class_attr_catch_re . ' )?	 # $8 = id/class attributes
 			)
 			}xs',
-            array(&$this, '_doAnchors_inline_callback'),
-            $text
-        );
-
-        #
-        # Last, handle reference-style shortcuts: [link text]
-        # These must come last in case you've also got [link text][1]
-        # or [link text](/foo)
-        #
-        $text = preg_replace_callback(
-            '{
+			array(&$this, '_doAnchors_inline_callback'),
+			$text
+		);
+
+		#
+		# Last, handle reference-style shortcuts: [link text]
+		# These must come last in case you've also got [link text][1]
+		# or [link text](/foo)
+		#
+		$text = preg_replace_callback(
+			'{
 			(					# wrap whole match in $1
 			  \[
 				([^\[\]]+)		# link text = $2; can\'t contain [ or ]
 			  \]
 			)
 			}xs',
-            array(&$this, '_doAnchors_reference_callback'),
-            $text
-        );
-
-        $this->in_anchor = false;
-        return $text;
-    }
-
-    function _doAnchors_reference_callback($matches)
-    {
-        $whole_match = $matches[1];
-        $link_text   = $matches[2];
-        $link_id     =& $matches[3];
-
-        if ($link_id == "") {
-            # for shortcut links like [this][] or [this].
-            $link_id = $link_text;
-        }
-
-        # lower-case and turn embedded newlines into spaces
-        $link_id = strtolower($link_id);
-        $link_id = preg_replace('{[ ]?\n}', ' ', $link_id);
-
-        if (isset($this->urls[$link_id])) {
-            $url = $this->urls[$link_id];
-            $url = $this->encodeAttribute($url);
-
-            $result = "<a href=\"$url\"";
-            if (isset($this->titles[$link_id])) {
-                $title = $this->titles[$link_id];
-                $title = $this->encodeAttribute($title);
-                $result .= " title=\"$title\"";
-            }
-            if (isset($this->ref_attr[$link_id])) {
-                $result .= $this->ref_attr[$link_id];
-            }
-
-            $link_text = $this->runSpanGamut($link_text);
-            $result .= ">$link_text</a>";
-            $result = $this->hashPart($result);
-        } else {
-            $result = $whole_match;
-        }
-        return $result;
-    }
-
-    function _doAnchors_inline_callback($matches)
-    {
-        $whole_match = $matches[1];
-        $link_text   = $this->runSpanGamut($matches[2]);
-        $url         = $matches[3] == '' ? $matches[4] : $matches[3];
-        $title       =& $matches[7];
-        $attr        = $this->doExtraAttributes("a", $dummy =& $matches[8]);
-
-        $url = $this->encodeAttribute($url);
-
-        $result = "<a href=\"$url\"";
-        if (isset($title)) {
-            $title = $this->encodeAttribute($title);
-            $result .= " title=\"$title\"";
-        }
-        $result .= $attr;
-
-        $link_text = $this->runSpanGamut($link_text);
-        $result .= ">$link_text</a>";
-
-        return $this->hashPart($result);
-    }
-
-    function doImages($text)
-    {
-        #
-        # Turn Markdown image shortcuts into <img> tags.
-        #
-        #
-        # First, handle reference-style labeled images: ![alt text][id]
-        #
-        $text = preg_replace_callback(
-            '{
+			array(&$this, '_doAnchors_reference_callback'),
+			$text
+		);
+
+		$this->in_anchor = false;
+		return $text;
+	}
+
+	function _doAnchors_reference_callback($matches)
+	{
+		$whole_match = $matches[1];
+		$link_text   = $matches[2];
+		$link_id     =& $matches[3];
+
+		if ($link_id == "") {
+			# for shortcut links like [this][] or [this].
+			$link_id = $link_text;
+		}
+
+		# lower-case and turn embedded newlines into spaces
+		$link_id = strtolower($link_id);
+		$link_id = preg_replace('{[ ]?\n}', ' ', $link_id);
+
+		if (isset($this->urls[$link_id])) {
+			$url = $this->urls[$link_id];
+			$url = $this->encodeAttribute($url);
+
+			$result = "<a href=\"$url\"";
+			if (isset($this->titles[$link_id])) {
+				$title = $this->titles[$link_id];
+				$title = $this->encodeAttribute($title);
+				$result .= " title=\"$title\"";
+			}
+			if (isset($this->ref_attr[$link_id])) {
+				$result .= $this->ref_attr[$link_id];
+			}
+
+			$link_text = $this->runSpanGamut($link_text);
+			$result .= ">$link_text</a>";
+			$result = $this->hashPart($result);
+		} else {
+			$result = $whole_match;
+		}
+		return $result;
+	}
+
+	function _doAnchors_inline_callback($matches)
+	{
+		$whole_match = $matches[1];
+		$link_text   = $this->runSpanGamut($matches[2]);
+		$url         = $matches[3] == '' ? $matches[4] : $matches[3];
+		$title       =& $matches[7];
+		$attr        = $this->doExtraAttributes("a", $dummy =& $matches[8]);
+
+		$url = $this->encodeAttribute($url);
+
+		$result = "<a href=\"$url\"";
+		if (isset($title)) {
+			$title = $this->encodeAttribute($title);
+			$result .= " title=\"$title\"";
+		}
+		$result .= $attr;
+
+		$link_text = $this->runSpanGamut($link_text);
+		$result .= ">$link_text</a>";
+
+		return $this->hashPart($result);
+	}
+
+	function doImages($text)
+	{
+		#
+		# Turn Markdown image shortcuts into <img> tags.
+		#
+		#
+		# First, handle reference-style labeled images: ![alt text][id]
+		#
+		$text = preg_replace_callback(
+			'{
 			(				# wrap whole match in $1
 			  !\[
 				(' . $this->nested_brackets_re . ')		# alt text = $2
@@ -2712,16 +2712,16 @@ 
 
 			)
 			}xs',
-            array(&$this, '_doImages_reference_callback'),
-            $text
-        );
-
-        #
-        # Next, handle inline images:  ![alt text](url "optional title")
-        # Don't forget: encode * and _
-        #
-        $text = preg_replace_callback(
-            '{
+			array(&$this, '_doImages_reference_callback'),
+			$text
+		);
+
+		#
+		# Next, handle inline images:  ![alt text](url "optional title")
+		# Don't forget: encode * and _
+		#
+		$text = preg_replace_callback(
+			'{
 			(				# wrap whole match in $1
 			  !\[
 				(' . $this->nested_brackets_re . ')		# alt text = $2
@@ -2745,97 +2745,97 @@ 
 			  (?:[ ]? ' . $this->id_class_attr_catch_re . ' )?	 # $8 = id/class attributes
 			)
 			}xs',
-            array(&$this, '_doImages_inline_callback'),
-            $text
-        );
-
-        return $text;
-    }
-
-    function _doImages_reference_callback($matches)
-    {
-        $whole_match = $matches[1];
-        $alt_text    = $matches[2];
-        $link_id     = strtolower($matches[3]);
-
-        if ($link_id == "") {
-            $link_id = strtolower($alt_text); # for shortcut links like ![this][].
-        }
-
-        $alt_text = $this->encodeAttribute($alt_text);
-        if (isset($this->urls[$link_id])) {
-            $url    = $this->encodeAttribute($this->urls[$link_id]);
-            $result = "<img src=\"$url\" alt=\"$alt_text\"";
-            if (isset($this->titles[$link_id])) {
-                $title = $this->titles[$link_id];
-                $title = $this->encodeAttribute($title);
-                $result .= " title=\"$title\"";
-            }
-            if (isset($this->ref_attr[$link_id])) {
-                $result .= $this->ref_attr[$link_id];
-            }
-            $result .= $this->empty_element_suffix;
-            $result = $this->hashPart($result);
-        } else {
-            # If there's no such link ID, leave intact:
-            $result = $whole_match;
-        }
-
-        return $result;
-    }
-
-    function _doImages_inline_callback($matches)
-    {
-        $whole_match = $matches[1];
-        $alt_text    = $matches[2];
-        $url         = $matches[3] == '' ? $matches[4] : $matches[3];
-        $title       =& $matches[7];
-        $attr        = $this->doExtraAttributes("img", $dummy =& $matches[8]);
-
-        $alt_text = $this->encodeAttribute($alt_text);
-        $url      = $this->encodeAttribute($url);
-        $result   = "<img src=\"$url\" alt=\"$alt_text\"";
-        if (isset($title)) {
-            $title = $this->encodeAttribute($title);
-            $result .= " title=\"$title\""; # $title already quoted
-        }
-        $result .= $attr;
-        $result .= $this->empty_element_suffix;
-
-        return $this->hashPart($result);
-    }
-
-    function doHeaders($text)
-    {
-        #
-        # Redefined to add id and class attribute support.
-        #
-        # Setext-style headers:
-        #	  Header 1  {#header1}
-        #	  ========
-        #
-        #	  Header 2  {#header2 .class1 .class2}
-        #	  --------
-        #
-        $text = preg_replace_callback(
-            '{
+			array(&$this, '_doImages_inline_callback'),
+			$text
+		);
+
+		return $text;
+	}
+
+	function _doImages_reference_callback($matches)
+	{
+		$whole_match = $matches[1];
+		$alt_text    = $matches[2];
+		$link_id     = strtolower($matches[3]);
+
+		if ($link_id == "") {
+			$link_id = strtolower($alt_text); # for shortcut links like ![this][].
+		}
+
+		$alt_text = $this->encodeAttribute($alt_text);
+		if (isset($this->urls[$link_id])) {
+			$url    = $this->encodeAttribute($this->urls[$link_id]);
+			$result = "<img src=\"$url\" alt=\"$alt_text\"";
+			if (isset($this->titles[$link_id])) {
+				$title = $this->titles[$link_id];
+				$title = $this->encodeAttribute($title);
+				$result .= " title=\"$title\"";
+			}
+			if (isset($this->ref_attr[$link_id])) {
+				$result .= $this->ref_attr[$link_id];
+			}
+			$result .= $this->empty_element_suffix;
+			$result = $this->hashPart($result);
+		} else {
+			# If there's no such link ID, leave intact:
+			$result = $whole_match;
+		}
+
+		return $result;
+	}
+
+	function _doImages_inline_callback($matches)
+	{
+		$whole_match = $matches[1];
+		$alt_text    = $matches[2];
+		$url         = $matches[3] == '' ? $matches[4] : $matches[3];
+		$title       =& $matches[7];
+		$attr        = $this->doExtraAttributes("img", $dummy =& $matches[8]);
+
+		$alt_text = $this->encodeAttribute($alt_text);
+		$url      = $this->encodeAttribute($url);
+		$result   = "<img src=\"$url\" alt=\"$alt_text\"";
+		if (isset($title)) {
+			$title = $this->encodeAttribute($title);
+			$result .= " title=\"$title\""; # $title already quoted
+		}
+		$result .= $attr;
+		$result .= $this->empty_element_suffix;
+
+		return $this->hashPart($result);
+	}
+
+	function doHeaders($text)
+	{
+		#
+		# Redefined to add id and class attribute support.
+		#
+		# Setext-style headers:
+		#	  Header 1  {#header1}
+		#	  ========
+		#
+		#	  Header 2  {#header2 .class1 .class2}
+		#	  --------
+		#
+		$text = preg_replace_callback(
+			'{
 				(^.+?)								# $1: Header text
 				(?:[ ]+ ' . $this->id_class_attr_catch_re . ' )?	 # $3 = id/class attributes
 				[ ]*\n(=+|-+)[ ]*\n+				# $3: Header footer
 			}mx',
-            array(&$this, '_doHeaders_callback_setext'),
-            $text
-        );
-
-        # atx-style headers:
-        #	# Header 1        {#header1}
-        #	## Header 2       {#header2}
-        #	## Header 2 with closing hashes ##  {#header3.class1.class2}
-        #	...
-        #	###### Header 6   {.class2}
-        #
-        $text = preg_replace_callback(
-            '{
+			array(&$this, '_doHeaders_callback_setext'),
+			$text
+		);
+
+		# atx-style headers:
+		#	# Header 1        {#header1}
+		#	## Header 2       {#header2}
+		#	## Header 2 with closing hashes ##  {#header3.class1.class2}
+		#	...
+		#	###### Header 6   {.class2}
+		#
+		$text = preg_replace_callback(
+			'{
 				^(\#{1,6})	# $1 = string of #\'s
 				[ ]*
 				(.+?)		# $2 = Header text
@@ -2845,48 +2845,48 @@ 
 				[ ]*
 				\n+
 			}xm',
-            array(&$this, '_doHeaders_callback_atx'),
-            $text
-        );
-
-        return $text;
-    }
-
-    function _doHeaders_callback_setext($matches)
-    {
-        if ($matches[3] == '-' && preg_match('{^- }', $matches[1])) {
-            return $matches[0];
-        }
-        $level = $matches[3]{0} == '=' ? 1 : 2;
-        $attr  = $this->doExtraAttributes("h$level", $dummy =& $matches[2]);
-        $block = "<h$level$attr>" . $this->runSpanGamut($matches[1]) . "</h$level>";
-        return "\n" . $this->hashBlock($block) . "\n\n";
-    }
-
-    function _doHeaders_callback_atx($matches)
-    {
-        $level = strlen($matches[1]);
-        $attr  = $this->doExtraAttributes("h$level", $dummy =& $matches[3]);
-        $block = "<h$level$attr>" . $this->runSpanGamut($matches[2]) . "</h$level>";
-        return "\n" . $this->hashBlock($block) . "\n\n";
-    }
-
-    function doTables($text)
-    {
-        #
-        # Form HTML tables.
-        #
-        $less_than_tab = $this->tab_width - 1;
-        #
-        # Find tables with leading pipe.
-        #
-        #	| Header 1 | Header 2
-        #	| -------- | --------
-        #	| Cell 1   | Cell 2
-        #	| Cell 3   | Cell 4
-        #
-        $text = preg_replace_callback(
-            '
+			array(&$this, '_doHeaders_callback_atx'),
+			$text
+		);
+
+		return $text;
+	}
+
+	function _doHeaders_callback_setext($matches)
+	{
+		if ($matches[3] == '-' && preg_match('{^- }', $matches[1])) {
+			return $matches[0];
+		}
+		$level = $matches[3]{0} == '=' ? 1 : 2;
+		$attr  = $this->doExtraAttributes("h$level", $dummy =& $matches[2]);
+		$block = "<h$level$attr>" . $this->runSpanGamut($matches[1]) . "</h$level>";
+		return "\n" . $this->hashBlock($block) . "\n\n";
+	}
+
+	function _doHeaders_callback_atx($matches)
+	{
+		$level = strlen($matches[1]);
+		$attr  = $this->doExtraAttributes("h$level", $dummy =& $matches[3]);
+		$block = "<h$level$attr>" . $this->runSpanGamut($matches[2]) . "</h$level>";
+		return "\n" . $this->hashBlock($block) . "\n\n";
+	}
+
+	function doTables($text)
+	{
+		#
+		# Form HTML tables.
+		#
+		$less_than_tab = $this->tab_width - 1;
+		#
+		# Find tables with leading pipe.
+		#
+		#	| Header 1 | Header 2
+		#	| -------- | --------
+		#	| Cell 1   | Cell 2
+		#	| Cell 3   | Cell 4
+		#
+		$text = preg_replace_callback(
+			'
 			{
 				^							# Start of a line
 				[ ]{0,' . $less_than_tab . '}	# Allowed whitespace.
@@ -2904,20 +2904,20 @@ 
 				)
 				(?=\n|\Z)					# Stop at final double newline.
 			}xm',
-            array(&$this, '_doTable_leadingPipe_callback'),
-            $text
-        );
-
-        #
-        # Find tables without leading pipe.
-        #
-        #	Header 1 | Header 2
-        #	-------- | --------
-        #	Cell 1   | Cell 2
-        #	Cell 3   | Cell 4
-        #
-        $text = preg_replace_callback(
-            '
+			array(&$this, '_doTable_leadingPipe_callback'),
+			$text
+		);
+
+		#
+		# Find tables without leading pipe.
+		#
+		#	Header 1 | Header 2
+		#	-------- | --------
+		#	Cell 1   | Cell 2
+		#	Cell 3   | Cell 4
+		#
+		$text = preg_replace_callback(
+			'
 			{
 				^							# Start of a line
 				[ ]{0,' . $less_than_tab . '}	# Allowed whitespace.
@@ -2933,101 +2933,101 @@ 
 				)
 				(?=\n|\Z)					# Stop at final double newline.
 			}xm',
-            array(&$this, '_DoTable_callback'),
-            $text
-        );
-
-        return $text;
-    }
-
-    function _doTable_leadingPipe_callback($matches)
-    {
-        $head      = $matches[1];
-        $underline = $matches[2];
-        $content   = $matches[3];
-
-        # Remove leading pipe for each row.
-        $content = preg_replace('/^ *[|]/m', '', $content);
-
-        return $this->_doTable_callback(array($matches[0], $head, $underline, $content));
-    }
-
-    function _doTable_callback($matches)
-    {
-        $head      = $matches[1];
-        $underline = $matches[2];
-        $content   = $matches[3];
-
-        # Remove any tailing pipes for each line.
-        $head      = preg_replace('/[|] *$/m', '', $head);
-        $underline = preg_replace('/[|] *$/m', '', $underline);
-        $content   = preg_replace('/[|] *$/m', '', $content);
-
-        # Reading alignement from header underline.
-        $separators = preg_split('/ *[|] */', $underline);
-        foreach ($separators as $n => $s) {
-            if (preg_match('/^ *-+: *$/', $s)) {
-                $attr[$n] = ' align="right"';
-            } else if (preg_match('/^ *:-+: *$/', $s)) {
-                $attr[$n] = ' align="center"';
-            } else if (preg_match('/^ *:-+ *$/', $s)) {
-                $attr[$n] = ' align="left"';
-            } else {
-                $attr[$n] = '';
-            }
-        }
-
-        # Parsing span elements, including code spans, character escapes,
-        # and inline HTML tags, so that pipes inside those gets ignored.
-        $head      = $this->parseSpan($head);
-        $headers   = preg_split('/ *[|] */', $head);
-        $col_count = count($headers);
-        $attr      = array_pad($attr, $col_count, '');
-
-        # Write column headers.
-        $text = "<table>\n";
-        $text .= "<thead>\n";
-        $text .= "<tr>\n";
-        foreach ($headers as $n => $header) {
-            $text .= "  <th$attr[$n]>" . $this->runSpanGamut(trim($header)) . "</th>\n";
-        }
-        $text .= "</tr>\n";
-        $text .= "</thead>\n";
-
-        # Split content by row.
-        $rows = explode("\n", trim($content, "\n"));
-
-        $text .= "<tbody>\n";
-        foreach ($rows as $row) {
-            # Parsing span elements, including code spans, character escapes,
-            # and inline HTML tags, so that pipes inside those gets ignored.
-            $row = $this->parseSpan($row);
-
-            # Split row by cell.
-            $row_cells = preg_split('/ *[|] */', $row, $col_count);
-            $row_cells = array_pad($row_cells, $col_count, '');
-
-            $text .= "<tr>\n";
-            foreach ($row_cells as $n => $cell) {
-                $text .= "  <td$attr[$n]>" . $this->runSpanGamut(trim($cell)) . "</td>\n";
-            }
-            $text .= "</tr>\n";
-        }
-        $text .= "</tbody>\n";
-        $text .= "</table>";
-
-        return $this->hashBlock($text) . "\n";
-    }
-
-    function doDefLists($text)
-    {
-        #
-        # Form HTML definition lists.
-        #
-        $less_than_tab = $this->tab_width - 1;
-
-        # Re-usable pattern to match any entire dl list:
-        $whole_list_re = '(?>
+			array(&$this, '_DoTable_callback'),
+			$text
+		);
+
+		return $text;
+	}
+
+	function _doTable_leadingPipe_callback($matches)
+	{
+		$head      = $matches[1];
+		$underline = $matches[2];
+		$content   = $matches[3];
+
+		# Remove leading pipe for each row.
+		$content = preg_replace('/^ *[|]/m', '', $content);
+
+		return $this->_doTable_callback(array($matches[0], $head, $underline, $content));
+	}
+
+	function _doTable_callback($matches)
+	{
+		$head      = $matches[1];
+		$underline = $matches[2];
+		$content   = $matches[3];
+
+		# Remove any tailing pipes for each line.
+		$head      = preg_replace('/[|] *$/m', '', $head);
+		$underline = preg_replace('/[|] *$/m', '', $underline);
+		$content   = preg_replace('/[|] *$/m', '', $content);
+
+		# Reading alignement from header underline.
+		$separators = preg_split('/ *[|] */', $underline);
+		foreach ($separators as $n => $s) {
+			if (preg_match('/^ *-+: *$/', $s)) {
+				$attr[$n] = ' align="right"';
+			} else if (preg_match('/^ *:-+: *$/', $s)) {
+				$attr[$n] = ' align="center"';
+			} else if (preg_match('/^ *:-+ *$/', $s)) {
+				$attr[$n] = ' align="left"';
+			} else {
+				$attr[$n] = '';
+			}
+		}
+
+		# Parsing span elements, including code spans, character escapes,
+		# and inline HTML tags, so that pipes inside those gets ignored.
+		$head      = $this->parseSpan($head);
+		$headers   = preg_split('/ *[|] */', $head);
+		$col_count = count($headers);
+		$attr      = array_pad($attr, $col_count, '');
+
+		# Write column headers.
+		$text = "<table>\n";
+		$text .= "<thead>\n";
+		$text .= "<tr>\n";
+		foreach ($headers as $n => $header) {
+			$text .= "  <th$attr[$n]>" . $this->runSpanGamut(trim($header)) . "</th>\n";
+		}
+		$text .= "</tr>\n";
+		$text .= "</thead>\n";
+
+		# Split content by row.
+		$rows = explode("\n", trim($content, "\n"));
+
+		$text .= "<tbody>\n";
+		foreach ($rows as $row) {
+			# Parsing span elements, including code spans, character escapes,
+			# and inline HTML tags, so that pipes inside those gets ignored.
+			$row = $this->parseSpan($row);
+
+			# Split row by cell.
+			$row_cells = preg_split('/ *[|] */', $row, $col_count);
+			$row_cells = array_pad($row_cells, $col_count, '');
+
+			$text .= "<tr>\n";
+			foreach ($row_cells as $n => $cell) {
+				$text .= "  <td$attr[$n]>" . $this->runSpanGamut(trim($cell)) . "</td>\n";
+			}
+			$text .= "</tr>\n";
+		}
+		$text .= "</tbody>\n";
+		$text .= "</table>";
+
+		return $this->hashBlock($text) . "\n";
+	}
+
+	function doDefLists($text)
+	{
+		#
+		# Form HTML definition lists.
+		#
+		$less_than_tab = $this->tab_width - 1;
+
+		# Re-usable pattern to match any entire dl list:
+		$whole_list_re = '(?>
 			(								# $1 = whole list
 			  (								# $2
 				[ ]{0,' . $less_than_tab . '}
@@ -3054,44 +3054,44 @@ 
 			)
 		)'; // mx
 
-        $text = preg_replace_callback(
-            '{
+		$text = preg_replace_callback(
+			'{
 				(?>\A\n?|(?<=\n\n))
 				' . $whole_list_re . '
 			}mx',
-            array(&$this, '_doDefLists_callback'),
-            $text
-        );
-
-        return $text;
-    }
-
-    function _doDefLists_callback($matches)
-    {
-        # Re-usable patterns to match list item bullets and number markers:
-        $list = $matches[1];
-
-        # Turn double returns into triple returns, so that we can make a
-        # paragraph for the last item in a list, if necessary:
-        $result = trim($this->processDefListItems($list));
-        $result = "<dl>\n" . $result . "\n</dl>";
-        return $this->hashBlock($result) . "\n\n";
-    }
-
-    function processDefListItems($list_str)
-    {
-        #
-        #	Process the contents of a single definition list, splitting it
-        #	into individual term and definition list items.
-        #
-        $less_than_tab = $this->tab_width - 1;
-
-        # trim trailing blank lines:
-        $list_str = preg_replace("/\n{2,}\\z/", "\n", $list_str);
-
-        # Process definition terms.
-        $list_str = preg_replace_callback(
-            '{
+			array(&$this, '_doDefLists_callback'),
+			$text
+		);
+
+		return $text;
+	}
+
+	function _doDefLists_callback($matches)
+	{
+		# Re-usable patterns to match list item bullets and number markers:
+		$list = $matches[1];
+
+		# Turn double returns into triple returns, so that we can make a
+		# paragraph for the last item in a list, if necessary:
+		$result = trim($this->processDefListItems($list));
+		$result = "<dl>\n" . $result . "\n</dl>";
+		return $this->hashBlock($result) . "\n\n";
+	}
+
+	function processDefListItems($list_str)
+	{
+		#
+		#	Process the contents of a single definition list, splitting it
+		#	into individual term and definition list items.
+		#
+		$less_than_tab = $this->tab_width - 1;
+
+		# trim trailing blank lines:
+		$list_str = preg_replace("/\n{2,}\\z/", "\n", $list_str);
+
+		# Process definition terms.
+		$list_str = preg_replace_callback(
+			'{
 			(?>\A\n?|\n\n+)					# leading line
 			(								# definition terms = $1
 				[ ]{0,' . $less_than_tab . '}	# leading whitespace
@@ -3102,13 +3102,13 @@ 
 			(?=\n?[ ]{0,3}:[ ])				# lookahead for following line feed
 											#   with a definition mark.
 			}xm',
-            array(&$this, '_processDefListItems_callback_dt'),
-            $list_str
-        );
+			array(&$this, '_processDefListItems_callback_dt'),
+			$list_str
+		);
 
-        # Process actual definitions.
-        $list_str = preg_replace_callback(
-            '{
+		# Process actual definitions.
+		$list_str = preg_replace_callback(
+			'{
 			\n(\n+)?						# leading line = $1
 			(								# marker space = $2
 				[ ]{0,' . $less_than_tab . '}	# whitespace before colon
@@ -3122,56 +3122,56 @@ 
 				)
 			)
 			}xm',
-            array(&$this, '_processDefListItems_callback_dd'),
-            $list_str
-        );
-
-        return $list_str;
-    }
-
-    function _processDefListItems_callback_dt($matches)
-    {
-        $terms = explode("\n", trim($matches[1]));
-        $text  = '';
-        foreach ($terms as $term) {
-            $term = $this->runSpanGamut(trim($term));
-            $text .= "\n<dt>" . $term . "</dt>";
-        }
-        return $text . "\n";
-    }
-
-    function _processDefListItems_callback_dd($matches)
-    {
-        $leading_line = $matches[1];
-        $marker_space = $matches[2];
-        $def          = $matches[3];
-
-        if ($leading_line || preg_match('/\n{2,}/', $def)) {
-            # Replace marker with the appropriate whitespace indentation
-            $def = str_repeat(' ', strlen($marker_space)) . $def;
-            $def = $this->runBlockGamut($this->outdent($def . "\n\n"));
-            $def = "\n" . $def . "\n";
-        } else {
-            $def = rtrim($def);
-            $def = $this->runSpanGamut($this->outdent($def));
-        }
-
-        return "\n<dd>" . $def . "</dd>\n";
-    }
-
-    function doFencedCodeBlocks($text)
-    {
-        #
-        # Adding the fenced code block syntax to regular Markdown:
-        #
-        # ~~~
-        # Code block
-        # ~~~
-        #
-        $less_than_tab = $this->tab_width;
-
-        $text = preg_replace_callback(
-            '{
+			array(&$this, '_processDefListItems_callback_dd'),
+			$list_str
+		);
+
+		return $list_str;
+	}
+
+	function _processDefListItems_callback_dt($matches)
+	{
+		$terms = explode("\n", trim($matches[1]));
+		$text  = '';
+		foreach ($terms as $term) {
+			$term = $this->runSpanGamut(trim($term));
+			$text .= "\n<dt>" . $term . "</dt>";
+		}
+		return $text . "\n";
+	}
+
+	function _processDefListItems_callback_dd($matches)
+	{
+		$leading_line = $matches[1];
+		$marker_space = $matches[2];
+		$def          = $matches[3];
+
+		if ($leading_line || preg_match('/\n{2,}/', $def)) {
+			# Replace marker with the appropriate whitespace indentation
+			$def = str_repeat(' ', strlen($marker_space)) . $def;
+			$def = $this->runBlockGamut($this->outdent($def . "\n\n"));
+			$def = "\n" . $def . "\n";
+		} else {
+			$def = rtrim($def);
+			$def = $this->runSpanGamut($this->outdent($def));
+		}
+
+		return "\n<dd>" . $def . "</dd>\n";
+	}
+
+	function doFencedCodeBlocks($text)
+	{
+		#
+		# Adding the fenced code block syntax to regular Markdown:
+		#
+		# ~~~
+		# Code block
+		# ~~~
+		#
+		$less_than_tab = $this->tab_width;
+
+		$text = preg_replace_callback(
+			'{
 				(?:\n|\A)
 				# 1: Opening marker
 				(
@@ -3196,120 +3196,120 @@ 
 				# Closing marker.
 				\1 [ ]* \n
 			}xm',
-            array(&$this, '_doFencedCodeBlocks_callback'),
-            $text
-        );
-
-        return $text;
-    }
-
-    function _doFencedCodeBlocks_callback($matches)
-    {
-        $classname =& $matches[2];
-        $attrs     =& $matches[3];
-        $codeblock = $matches[4];
-        $codeblock = htmlspecialchars($codeblock, ENT_NOQUOTES);
-        $codeblock = preg_replace_callback(
-            '/^\n+/',
-            array(&$this, '_doFencedCodeBlocks_newlines'),
-            $codeblock
-        );
-
-        if ($classname != "") {
-            if ($classname{0} == '.') {
-                $classname = substr($classname, 1);
-            }
-            $attr_str = ' class="' . $this->code_class_prefix . $classname . '"';
-        } else {
-            $attr_str = $this->doExtraAttributes($this->code_attr_on_pre ? "pre" : "code", $attrs);
-        }
-        $pre_attr_str  = $this->code_attr_on_pre ? $attr_str : '';
-        $code_attr_str = $this->code_attr_on_pre ? '' : $attr_str;
-        $codeblock     = "<pre$pre_attr_str><code$code_attr_str>$codeblock</code></pre>";
-
-        return "\n\n" . $this->hashBlock($codeblock) . "\n\n";
-    }
-
-    function _doFencedCodeBlocks_newlines($matches)
-    {
-        return str_repeat(
-            "<br$this->empty_element_suffix",
-            strlen($matches[0])
-        );
-    }
-
-
-    #
-    # Redefining emphasis markers so that emphasis by underscore does not
-    # work in the middle of a word.
-    #
-    var $em_relist = array(
-        ''  => '(?:(?<!\*)\*(?!\*)|(?<![a-zA-Z0-9_])_(?!_))(?=\S|$)(?![\.,:;]\s)',
-        '*' => '(?<=\S|^)(?<!\*)\*(?!\*)',
-        '_' => '(?<=\S|^)(?<!_)_(?![a-zA-Z0-9_])',
-    );
-
-    var $strong_relist = array(
-        ''   => '(?:(?<!\*)\*\*(?!\*)|(?<![a-zA-Z0-9_])__(?!_))(?=\S|$)(?![\.,:;]\s)',
-        '**' => '(?<=\S|^)(?<!\*)\*\*(?!\*)',
-        '__' => '(?<=\S|^)(?<!_)__(?![a-zA-Z0-9_])',
-    );
-
-    var $em_strong_relist = array(
-        ''    => '(?:(?<!\*)\*\*\*(?!\*)|(?<![a-zA-Z0-9_])___(?!_))(?=\S|$)(?![\.,:;]\s)',
-        '***' => '(?<=\S|^)(?<!\*)\*\*\*(?!\*)',
-        '___' => '(?<=\S|^)(?<!_)___(?![a-zA-Z0-9_])',
-    );
-
-    function formParagraphs($text)
-    {
-        #
-        #	Params:
-        #		$text - string to process with html <p> tags
-        #
-        # Strip leading and trailing lines:
-        $text = preg_replace('/\A\n+|\n+\z/', '', $text);
-
-        $grafs = preg_split('/\n{2,}/', $text, - 1, PREG_SPLIT_NO_EMPTY);
-
-        #
-        # Wrap <p> tags and unhashify HTML blocks
-        #
-        foreach ($grafs as $key => $value) {
-            $value = trim($this->runSpanGamut($value));
-
-            # Check if this should be enclosed in a paragraph.
-            # Clean tag hashes & block tag hashes are left alone.
-            $is_p = !preg_match('/^B\x1A[0-9]+B|^C\x1A[0-9]+C$/', $value);
-
-            if ($is_p) {
-                $value = "<p>$value</p>";
-            }
-            $grafs[$key] = $value;
-        }
-
-        # Join grafs in one text, then unhash HTML tags.
-        $text = implode("\n\n", $grafs);
-
-        # Finish by removing any tag hashes still present in $text.
-        $text = $this->unhash($text);
-
-        return $text;
-    }
-
-    ### Footnotes
-
-    function stripFootnotes($text)
-    {
-        #
-        # Strips link definitions from text, stores the URLs and titles in
-        # hash references.
-        #
-        $less_than_tab = $this->tab_width - 1;
-
-        # Link defs are in the form: [^id]: url "optional title"
-        $text = preg_replace_callback(
-            '{
+			array(&$this, '_doFencedCodeBlocks_callback'),
+			$text
+		);
+
+		return $text;
+	}
+
+	function _doFencedCodeBlocks_callback($matches)
+	{
+		$classname =& $matches[2];
+		$attrs     =& $matches[3];
+		$codeblock = $matches[4];
+		$codeblock = htmlspecialchars($codeblock, ENT_NOQUOTES);
+		$codeblock = preg_replace_callback(
+			'/^\n+/',
+			array(&$this, '_doFencedCodeBlocks_newlines'),
+			$codeblock
+		);
+
+		if ($classname != "") {
+			if ($classname{0} == '.') {
+				$classname = substr($classname, 1);
+			}
+			$attr_str = ' class="' . $this->code_class_prefix . $classname . '"';
+		} else {
+			$attr_str = $this->doExtraAttributes($this->code_attr_on_pre ? "pre" : "code", $attrs);
+		}
+		$pre_attr_str  = $this->code_attr_on_pre ? $attr_str : '';
+		$code_attr_str = $this->code_attr_on_pre ? '' : $attr_str;
+		$codeblock     = "<pre$pre_attr_str><code$code_attr_str>$codeblock</code></pre>";
+
+		return "\n\n" . $this->hashBlock($codeblock) . "\n\n";
+	}
+
+	function _doFencedCodeBlocks_newlines($matches)
+	{
+		return str_repeat(
+			"<br$this->empty_element_suffix",
+			strlen($matches[0])
+		);
+	}
+
+
+	#
+	# Redefining emphasis markers so that emphasis by underscore does not
+	# work in the middle of a word.
+	#
+	var $em_relist = array(
+		''  => '(?:(?<!\*)\*(?!\*)|(?<![a-zA-Z0-9_])_(?!_))(?=\S|$)(?![\.,:;]\s)',
+		'*' => '(?<=\S|^)(?<!\*)\*(?!\*)',
+		'_' => '(?<=\S|^)(?<!_)_(?![a-zA-Z0-9_])',
+	);
+
+	var $strong_relist = array(
+		''   => '(?:(?<!\*)\*\*(?!\*)|(?<![a-zA-Z0-9_])__(?!_))(?=\S|$)(?![\.,:;]\s)',
+		'**' => '(?<=\S|^)(?<!\*)\*\*(?!\*)',
+		'__' => '(?<=\S|^)(?<!_)__(?![a-zA-Z0-9_])',
+	);
+
+	var $em_strong_relist = array(
+		''    => '(?:(?<!\*)\*\*\*(?!\*)|(?<![a-zA-Z0-9_])___(?!_))(?=\S|$)(?![\.,:;]\s)',
+		'***' => '(?<=\S|^)(?<!\*)\*\*\*(?!\*)',
+		'___' => '(?<=\S|^)(?<!_)___(?![a-zA-Z0-9_])',
+	);
+
+	function formParagraphs($text)
+	{
+		#
+		#	Params:
+		#		$text - string to process with html <p> tags
+		#
+		# Strip leading and trailing lines:
+		$text = preg_replace('/\A\n+|\n+\z/', '', $text);
+
+		$grafs = preg_split('/\n{2,}/', $text, - 1, PREG_SPLIT_NO_EMPTY);
+
+		#
+		# Wrap <p> tags and unhashify HTML blocks
+		#
+		foreach ($grafs as $key => $value) {
+			$value = trim($this->runSpanGamut($value));
+
+			# Check if this should be enclosed in a paragraph.
+			# Clean tag hashes & block tag hashes are left alone.
+			$is_p = !preg_match('/^B\x1A[0-9]+B|^C\x1A[0-9]+C$/', $value);
+
+			if ($is_p) {
+				$value = "<p>$value</p>";
+			}
+			$grafs[$key] = $value;
+		}
+
+		# Join grafs in one text, then unhash HTML tags.
+		$text = implode("\n\n", $grafs);
+
+		# Finish by removing any tag hashes still present in $text.
+		$text = $this->unhash($text);
+
+		return $text;
+	}
+
+	### Footnotes
+
+	function stripFootnotes($text)
+	{
+		#
+		# Strips link definitions from text, stores the URLs and titles in
+		# hash references.
+		#
+		$less_than_tab = $this->tab_width - 1;
+
+		# Link defs are in the form: [^id]: url "optional title"
+		$text = preg_replace_callback(
+			'{
 			^[ ]{0,' . $less_than_tab . '}\[\^(.+?)\][ ]?:	# note_id = $1
 			  [ ]*
 			  \n?					# maybe *one* newline
@@ -3324,215 +3324,215 @@ 
 				)*
 			)
 			}xm',
-            array(&$this, '_stripFootnotes_callback'),
-            $text
-        );
-        return $text;
-    }
-
-    function _stripFootnotes_callback($matches)
-    {
-        $note_id                   = $this->fn_id_prefix . $matches[1];
-        $this->footnotes[$note_id] = $this->outdent($matches[2]);
-        return ''; # String that will replace the block
-    }
-
-    function doFootnotes($text)
-    {
-        #
-        # Replace footnote references in $text [^id] with a special text-token
-        # which will be replaced by the actual footnote marker in appendFootnotes.
-        #
-        if (!$this->in_anchor) {
-            $text = preg_replace('{\[\^(.+?)\]}', "F\x1Afn:\\1\x1A:", $text);
-        }
-        return $text;
-    }
-
-    function appendFootnotes($text)
-    {
-        #
-        # Append footnote list to text.
-        #
-        $text = preg_replace_callback(
-            '{F\x1Afn:(.*?)\x1A:}',
-            array(&$this, '_appendFootnotes_callback'),
-            $text
-        );
-
-        if (!empty($this->footnotes_ordered)) {
-            $text .= "\n\n";
-            $text .= "<div class=\"footnotes\">\n";
-            $text .= "<hr" . $this->empty_element_suffix . "\n";
-            $text .= "<ol>\n\n";
-
-            $attr = " rev=\"footnote\"";
-            if ($this->fn_backlink_class != "") {
-                $class = $this->fn_backlink_class;
-                $class = $this->encodeAttribute($class);
-                $attr .= " class=\"$class\"";
-            }
-            if ($this->fn_backlink_title != "") {
-                $title = $this->fn_backlink_title;
-                $title = $this->encodeAttribute($title);
-                $attr .= " title=\"$title\"";
-            }
-            $num = 0;
-
-            while (!empty($this->footnotes_ordered)) {
-                $footnote = reset($this->footnotes_ordered);
-                $note_id  = key($this->footnotes_ordered);
-                unset($this->footnotes_ordered[$note_id]);
-                $ref_count = $this->footnotes_ref_count[$note_id];
-                unset($this->footnotes_ref_count[$note_id]);
-                unset($this->footnotes[$note_id]);
-
-                $footnote .= "\n"; # Need to append newline before parsing.
-                $footnote = $this->runBlockGamut("$footnote\n");
-                $footnote = preg_replace_callback(
-                    '{F\x1Afn:(.*?)\x1A:}',
-                    array(&$this, '_appendFootnotes_callback'),
-                    $footnote
-                );
-
-                $attr    = str_replace("%%", ++ $num, $attr);
-                $note_id = $this->encodeAttribute($note_id);
-
-                # Prepare backlink, multiple backlinks if multiple references
-                $backlink = "<a href=\"#fnref:$note_id\"$attr>&#8617;</a>";
-                for ($ref_num = 2; $ref_num <= $ref_count; ++ $ref_num) {
-                    $backlink .= " <a href=\"#fnref$ref_num:$note_id\"$attr>&#8617;</a>";
-                }
-                # Add backlink to last paragraph; create new paragraph if needed.
-                if (preg_match('{</p>$}', $footnote)) {
-                    $footnote = substr($footnote, 0, - 4) . "&#160;$backlink</p>";
-                } else {
-                    $footnote .= "\n\n<p>$backlink</p>";
-                }
-
-                $text .= "<li id=\"fn:$note_id\">\n";
-                $text .= $footnote . "\n";
-                $text .= "</li>\n\n";
-            }
-
-            $text .= "</ol>\n";
-            $text .= "</div>";
-        }
-        return $text;
-    }
-
-    function _appendFootnotes_callback($matches)
-    {
-        $node_id = $this->fn_id_prefix . $matches[1];
-
-        # Create footnote marker only if it has a corresponding footnote *and*
-        # the footnote hasn't been used by another marker.
-        if (isset($this->footnotes[$node_id])) {
-            $num =& $this->footnotes_numbers[$node_id];
-            if (!isset($num)) {
-                # Transfer footnote content to the ordered list and give it its
-                # number
-                $this->footnotes_ordered[$node_id]   = $this->footnotes[$node_id];
-                $this->footnotes_ref_count[$node_id] = 1;
-                $num                                 = $this->footnote_counter ++;
-                $ref_count_mark                      = '';
-            } else {
-                $ref_count_mark = $this->footnotes_ref_count[$node_id] += 1;
-            }
-
-            $attr = " rel=\"footnote\"";
-            if ($this->fn_link_class != "") {
-                $class = $this->fn_link_class;
-                $class = $this->encodeAttribute($class);
-                $attr .= " class=\"$class\"";
-            }
-            if ($this->fn_link_title != "") {
-                $title = $this->fn_link_title;
-                $title = $this->encodeAttribute($title);
-                $attr .= " title=\"$title\"";
-            }
-
-            $attr    = str_replace("%%", $num, $attr);
-            $node_id = $this->encodeAttribute($node_id);
-
-            return
-                "<sup id=\"fnref$ref_count_mark:$node_id\">" .
-                "<a href=\"#fn:$node_id\"$attr>$num</a>" .
-                "</sup>";
-        }
-
-        return "[^" . $matches[1] . "]";
-    }
-
-    ### Abbreviations ###
-
-    function stripAbbreviations($text)
-    {
-        #
-        # Strips abbreviations from text, stores titles in hash references.
-        #
-        $less_than_tab = $this->tab_width - 1;
-
-        # Link defs are in the form: [id]*: url "optional title"
-        $text = preg_replace_callback(
-            '{
+			array(&$this, '_stripFootnotes_callback'),
+			$text
+		);
+		return $text;
+	}
+
+	function _stripFootnotes_callback($matches)
+	{
+		$note_id                   = $this->fn_id_prefix . $matches[1];
+		$this->footnotes[$note_id] = $this->outdent($matches[2]);
+		return ''; # String that will replace the block
+	}
+
+	function doFootnotes($text)
+	{
+		#
+		# Replace footnote references in $text [^id] with a special text-token
+		# which will be replaced by the actual footnote marker in appendFootnotes.
+		#
+		if (!$this->in_anchor) {
+			$text = preg_replace('{\[\^(.+?)\]}', "F\x1Afn:\\1\x1A:", $text);
+		}
+		return $text;
+	}
+
+	function appendFootnotes($text)
+	{
+		#
+		# Append footnote list to text.
+		#
+		$text = preg_replace_callback(
+			'{F\x1Afn:(.*?)\x1A:}',
+			array(&$this, '_appendFootnotes_callback'),
+			$text
+		);
+
+		if (!empty($this->footnotes_ordered)) {
+			$text .= "\n\n";
+			$text .= "<div class=\"footnotes\">\n";
+			$text .= "<hr" . $this->empty_element_suffix . "\n";
+			$text .= "<ol>\n\n";
+
+			$attr = " rev=\"footnote\"";
+			if ($this->fn_backlink_class != "") {
+				$class = $this->fn_backlink_class;
+				$class = $this->encodeAttribute($class);
+				$attr .= " class=\"$class\"";
+			}
+			if ($this->fn_backlink_title != "") {
+				$title = $this->fn_backlink_title;
+				$title = $this->encodeAttribute($title);
+				$attr .= " title=\"$title\"";
+			}
+			$num = 0;
+
+			while (!empty($this->footnotes_ordered)) {
+				$footnote = reset($this->footnotes_ordered);
+				$note_id  = key($this->footnotes_ordered);
+				unset($this->footnotes_ordered[$note_id]);
+				$ref_count = $this->footnotes_ref_count[$note_id];
+				unset($this->footnotes_ref_count[$note_id]);
+				unset($this->footnotes[$note_id]);
+
+				$footnote .= "\n"; # Need to append newline before parsing.
+				$footnote = $this->runBlockGamut("$footnote\n");
+				$footnote = preg_replace_callback(
+					'{F\x1Afn:(.*?)\x1A:}',
+					array(&$this, '_appendFootnotes_callback'),
+					$footnote
+				);
+
+				$attr    = str_replace("%%", ++ $num, $attr);
+				$note_id = $this->encodeAttribute($note_id);
+
+				# Prepare backlink, multiple backlinks if multiple references
+				$backlink = "<a href=\"#fnref:$note_id\"$attr>&#8617;</a>";
+				for ($ref_num = 2; $ref_num <= $ref_count; ++ $ref_num) {
+					$backlink .= " <a href=\"#fnref$ref_num:$note_id\"$attr>&#8617;</a>";
+				}
+				# Add backlink to last paragraph; create new paragraph if needed.
+				if (preg_match('{</p>$}', $footnote)) {
+					$footnote = substr($footnote, 0, - 4) . "&#160;$backlink</p>";
+				} else {
+					$footnote .= "\n\n<p>$backlink</p>";
+				}
+
+				$text .= "<li id=\"fn:$note_id\">\n";
+				$text .= $footnote . "\n";
+				$text .= "</li>\n\n";
+			}
+
+			$text .= "</ol>\n";
+			$text .= "</div>";
+		}
+		return $text;
+	}
+
+	function _appendFootnotes_callback($matches)
+	{
+		$node_id = $this->fn_id_prefix . $matches[1];
+
+		# Create footnote marker only if it has a corresponding footnote *and*
+		# the footnote hasn't been used by another marker.
+		if (isset($this->footnotes[$node_id])) {
+			$num =& $this->footnotes_numbers[$node_id];
+			if (!isset($num)) {
+				# Transfer footnote content to the ordered list and give it its
+				# number
+				$this->footnotes_ordered[$node_id]   = $this->footnotes[$node_id];
+				$this->footnotes_ref_count[$node_id] = 1;
+				$num                                 = $this->footnote_counter ++;
+				$ref_count_mark                      = '';
+			} else {
+				$ref_count_mark = $this->footnotes_ref_count[$node_id] += 1;
+			}
+
+			$attr = " rel=\"footnote\"";
+			if ($this->fn_link_class != "") {
+				$class = $this->fn_link_class;
+				$class = $this->encodeAttribute($class);
+				$attr .= " class=\"$class\"";
+			}
+			if ($this->fn_link_title != "") {
+				$title = $this->fn_link_title;
+				$title = $this->encodeAttribute($title);
+				$attr .= " title=\"$title\"";
+			}
+
+			$attr    = str_replace("%%", $num, $attr);
+			$node_id = $this->encodeAttribute($node_id);
+
+			return
+				"<sup id=\"fnref$ref_count_mark:$node_id\">" .
+				"<a href=\"#fn:$node_id\"$attr>$num</a>" .
+				"</sup>";
+		}
+
+		return "[^" . $matches[1] . "]";
+	}
+
+	### Abbreviations ###
+
+	function stripAbbreviations($text)
+	{
+		#
+		# Strips abbreviations from text, stores titles in hash references.
+		#
+		$less_than_tab = $this->tab_width - 1;
+
+		# Link defs are in the form: [id]*: url "optional title"
+		$text = preg_replace_callback(
+			'{
 			^[ ]{0,' . $less_than_tab . '}\*\[(.+?)\][ ]?:	# abbr_id = $1
 			(.*)					# text = $2 (no blank lines allowed)
 			}xm',
-            array(&$this, '_stripAbbreviations_callback'),
-            $text
-        );
-        return $text;
-    }
-
-    function _stripAbbreviations_callback($matches)
-    {
-        $abbr_word = $matches[1];
-        $abbr_desc = $matches[2];
-        if ($this->abbr_word_re) {
-            $this->abbr_word_re .= '|';
-        }
-        $this->abbr_word_re .= preg_quote($abbr_word);
-        $this->abbr_desciptions[$abbr_word] = trim($abbr_desc);
-        return ''; # String that will replace the block
-    }
-
-    function doAbbreviations($text)
-    {
-        #
-        # Find defined abbreviations in text and wrap them in <abbr> elements.
-        #
-        if ($this->abbr_word_re) {
-            // cannot use the /x modifier because abbr_word_re may
-            // contain significant spaces:
-            $text = preg_replace_callback(
-                '{' .
-                '(?<![\w\x1A])' .
-                '(?:' . $this->abbr_word_re . ')' .
-                '(?![\w\x1A])' .
-                '}',
-                array(&$this, '_doAbbreviations_callback'),
-                $text
-            );
-        }
-        return $text;
-    }
-
-    function _doAbbreviations_callback($matches)
-    {
-        $abbr = $matches[0];
-        if (isset($this->abbr_desciptions[$abbr])) {
-            $desc = $this->abbr_desciptions[$abbr];
-            if (empty($desc)) {
-                return $this->hashPart("<abbr>$abbr</abbr>");
-            } else {
-                $desc = $this->encodeAttribute($desc);
-                return $this->hashPart("<abbr title=\"$desc\">$abbr</abbr>");
-            }
-        } else {
-            return $matches[0];
-        }
-    }
+			array(&$this, '_stripAbbreviations_callback'),
+			$text
+		);
+		return $text;
+	}
+
+	function _stripAbbreviations_callback($matches)
+	{
+		$abbr_word = $matches[1];
+		$abbr_desc = $matches[2];
+		if ($this->abbr_word_re) {
+			$this->abbr_word_re .= '|';
+		}
+		$this->abbr_word_re .= preg_quote($abbr_word);
+		$this->abbr_desciptions[$abbr_word] = trim($abbr_desc);
+		return ''; # String that will replace the block
+	}
+
+	function doAbbreviations($text)
+	{
+		#
+		# Find defined abbreviations in text and wrap them in <abbr> elements.
+		#
+		if ($this->abbr_word_re) {
+			// cannot use the /x modifier because abbr_word_re may
+			// contain significant spaces:
+			$text = preg_replace_callback(
+				'{' .
+				'(?<![\w\x1A])' .
+				'(?:' . $this->abbr_word_re . ')' .
+				'(?![\w\x1A])' .
+				'}',
+				array(&$this, '_doAbbreviations_callback'),
+				$text
+			);
+		}
+		return $text;
+	}
+
+	function _doAbbreviations_callback($matches)
+	{
+		$abbr = $matches[0];
+		if (isset($this->abbr_desciptions[$abbr])) {
+			$desc = $this->abbr_desciptions[$abbr];
+			if (empty($desc)) {
+				return $this->hashPart("<abbr>$abbr</abbr>");
+			} else {
+				$desc = $this->encodeAttribute($desc);
+				return $this->hashPart("<abbr title=\"$desc\">$abbr</abbr>");
+			}
+		} else {
+			return $matches[0];
+		}
+	}
 }
 
 /*

myth/Models/CIDbModel.php

Indentation +1420 added lines, -1420 removed lines

@@ -102,1479 +102,1479 @@
 class CIDbModel
 {
 
-    /**
-     * The model's default table name.
-     *
-     * @var string;
-     */
-    protected $table_name;
-
-    /**
-     * The model's default primary key.
-     *
-     * @var string
-     */
-    protected $primary_key = 'id';
-
-    /**
-     * The type of date/time field used for created_on and modified_on fields.
-     * Valid types are: 'int', 'datetime', 'date'
-     *
-     * @var string
-     * @access protected
-     */
-    protected $date_format = 'datetime';
-
-    /*
+	/**
+	 * The model's default table name.
+	 *
+	 * @var string;
+	 */
+	protected $table_name;
+
+	/**
+	 * The model's default primary key.
+	 *
+	 * @var string
+	 */
+	protected $primary_key = 'id';
+
+	/**
+	 * The type of date/time field used for created_on and modified_on fields.
+	 * Valid types are: 'int', 'datetime', 'date'
+	 *
+	 * @var string
+	 * @access protected
+	 */
+	protected $date_format = 'datetime';
+
+	/*
         Var: $log_user
         If TRUE, will log user id for 'created_by', 'modified_by' and 'deleted_by'.
 
         Access:
             Protected
     */
-    protected $log_user = FALSE;
+	protected $log_user = FALSE;
 
 
 
-    /**
-     * Whether or not to auto-fill a 'created_on' field on inserts.
-     *
-     * @var boolean
-     * @access protected
-     */
-    protected $set_created = TRUE;
+	/**
+	 * Whether or not to auto-fill a 'created_on' field on inserts.
+	 *
+	 * @var boolean
+	 * @access protected
+	 */
+	protected $set_created = TRUE;
 
-    /**
-     * Field name to use to the created time column in the DB table.
-     *
-     * @var string
-     * @access protected
-     */
-    protected $created_field = 'created_on';
+	/**
+	 * Field name to use to the created time column in the DB table.
+	 *
+	 * @var string
+	 * @access protected
+	 */
+	protected $created_field = 'created_on';
 
-    /*
+	/*
         Var: $created_by_field
         Field name to use to the created by column in the DB table.
 
         Access:
             Protected
     */
-    protected $created_by_field = 'created_by';
+	protected $created_by_field = 'created_by';
 
 
 
-    /**
-     * Whether or not to auto-fill a 'modified_on' field on updates.
-     *
-     * @var boolean
-     * @access protected
-     */
-    protected $set_modified = TRUE;
+	/**
+	 * Whether or not to auto-fill a 'modified_on' field on updates.
+	 *
+	 * @var boolean
+	 * @access protected
+	 */
+	protected $set_modified = TRUE;
 
-    /**
-     * Field name to use to the modified time column in the DB table.
-     *
-     * @var string
-     * @access protected
-     */
-    protected $modified_field = 'modified_on';
+	/**
+	 * Field name to use to the modified time column in the DB table.
+	 *
+	 * @var string
+	 * @access protected
+	 */
+	protected $modified_field = 'modified_on';
 
-    /*
+	/*
         Var: $modified_by_field
         Field name to use to the modified by column in the DB table.
 
         Access:
             Protected
     */
-    protected $modified_by_field = 'modified_by';
+	protected $modified_by_field = 'modified_by';
 
 
-    /**
-     * Support for soft_deletes.
-     */
-    protected $soft_deletes = FALSE;
-    protected $soft_delete_key = 'deleted';
-    protected $temp_with_deleted = FALSE;
+	/**
+	 * Support for soft_deletes.
+	 */
+	protected $soft_deletes = FALSE;
+	protected $soft_delete_key = 'deleted';
+	protected $temp_with_deleted = FALSE;
 
-    /*
+	/*
         Var: $deleted_by_field
         Field name to use for the deleted by column in the DB table.
 
         Access:
             Protected
     */
-    protected $deleted_by_field = 'deleted_by';
+	protected $deleted_by_field = 'deleted_by';
 
 
 
-    /**
-     * Various callbacks available to the class. They are simple lists of
-     * method names (methods will be ran on $this).
-     */
-    protected $before_insert = array();
-    protected $after_insert = array();
-    protected $before_update = array();
-    protected $after_update = array();
-    protected $before_find = array();
-    protected $after_find = array();
-    protected $before_delete = array();
-    protected $after_delete = array();
+	/**
+	 * Various callbacks available to the class. They are simple lists of
+	 * method names (methods will be ran on $this).
+	 */
+	protected $before_insert = array();
+	protected $after_insert = array();
+	protected $before_update = array();
+	protected $after_update = array();
+	protected $before_find = array();
+	protected $after_find = array();
+	protected $before_delete = array();
+	protected $after_delete = array();
 
-    protected $callback_parameters = array();
+	protected $callback_parameters = array();
 
 
 
-    /*
+	/*
         If TRUE, inserts will return the last_insert_id. However,
         this can potentially slow down large imports drastically
         so you can turn it off with the return_insert_id(false) method.
      */
-    protected $return_insert_id = true;
-
-    /**
-     * By default, we return items as objects. You can change this for the
-     * entire class by setting this value to 'array' instead of 'object'.
-     * Alternatively, you can do it on a per-instance basis using the
-     * 'as_array()' and 'as_object()' methods.
-     */
-    protected $return_type = 'object';
-    protected $temp_return_type = NULL;
-
-    /**
-     * Protected, non-modifiable attributes
-     */
-    protected $protected_attributes = array();
-
-
-
-    /**
-     * An array of validation rules. This needs to be the same format
-     * as validation rules passed to the Form_validation library.
-     */
-    protected $validation_rules = array();
-
-    /**
-     * Optionally skip the validation. Used in conjunction with
-     * skip_validation() to skip data validation for any future calls.
-     */
-    protected $skip_validation = FALSE;
-
-    /**
-     * An array of extra rules to add to validation rules during inserts only.
-     * Often used for adding 'required' rules to fields on insert, but not udpates.
-     *
-     *   array( 'username' => 'required|strip_tags' );
-     * @var array
-     */
-    protected $insert_validate_rules = array();
-
-
-
-    /**
-     * @var Array Columns for the model's database fields
-     *
-     * This can be set to avoid a database call if using $this->prep_data()
-     */
-    protected $fields = array();
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Does basic setup. Can pass the database connection into the constructor
-     * to use that $db instead of the global CI one.
-     *
-     * @param object $db // A database/driver instance
-     * @param object $form_validation // A form_validation library instance
-     */
-    public function __construct($db = null, $form_validation = null)
-    {
-        // Always protect our attributes
-        array_unshift($this->before_insert, 'protect_attributes');
-        array_unshift($this->before_update, 'protect_attributes');
-
-        // Check our auto-set features and make sure they are part of
-        // our observer system.
-        if ($this->set_created === true) array_unshift($this->before_insert, 'created_on');
-        if ($this->set_modified === true) array_unshift($this->before_update, 'modified_on');
-
-        // Make sure our temp return type is correct.
-        $this->temp_return_type = $this->return_type;
-
-        // Make sure our database is loaded
-        if (!is_null($db)) {
-            $this->db = $db;
-        }
-        else {
-            // Auto Init the damn database....
-            $this->load->database();
-        }
-
-        // Do we have a form_validation library?
-        if (! is_null($form_validation)) {
-            $this->form_validation = $form_validation;
-        }
-        else {
-            $this->load->library('form_validation');
-        }
+	protected $return_insert_id = true;
+
+	/**
+	 * By default, we return items as objects. You can change this for the
+	 * entire class by setting this value to 'array' instead of 'object'.
+	 * Alternatively, you can do it on a per-instance basis using the
+	 * 'as_array()' and 'as_object()' methods.
+	 */
+	protected $return_type = 'object';
+	protected $temp_return_type = NULL;
+
+	/**
+	 * Protected, non-modifiable attributes
+	 */
+	protected $protected_attributes = array();
+
+
+
+	/**
+	 * An array of validation rules. This needs to be the same format
+	 * as validation rules passed to the Form_validation library.
+	 */
+	protected $validation_rules = array();
+
+	/**
+	 * Optionally skip the validation. Used in conjunction with
+	 * skip_validation() to skip data validation for any future calls.
+	 */
+	protected $skip_validation = FALSE;
+
+	/**
+	 * An array of extra rules to add to validation rules during inserts only.
+	 * Often used for adding 'required' rules to fields on insert, but not udpates.
+	 *
+	 *   array( 'username' => 'required|strip_tags' );
+	 * @var array
+	 */
+	protected $insert_validate_rules = array();
+
+
+
+	/**
+	 * @var Array Columns for the model's database fields
+	 *
+	 * This can be set to avoid a database call if using $this->prep_data()
+	 */
+	protected $fields = array();
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Does basic setup. Can pass the database connection into the constructor
+	 * to use that $db instead of the global CI one.
+	 *
+	 * @param object $db // A database/driver instance
+	 * @param object $form_validation // A form_validation library instance
+	 */
+	public function __construct($db = null, $form_validation = null)
+	{
+		// Always protect our attributes
+		array_unshift($this->before_insert, 'protect_attributes');
+		array_unshift($this->before_update, 'protect_attributes');
+
+		// Check our auto-set features and make sure they are part of
+		// our observer system.
+		if ($this->set_created === true) array_unshift($this->before_insert, 'created_on');
+		if ($this->set_modified === true) array_unshift($this->before_update, 'modified_on');
+
+		// Make sure our temp return type is correct.
+		$this->temp_return_type = $this->return_type;
+
+		// Make sure our database is loaded
+		if (!is_null($db)) {
+			$this->db = $db;
+		}
+		else {
+			// Auto Init the damn database....
+			$this->load->database();
+		}
+
+		// Do we have a form_validation library?
+		if (! is_null($form_validation)) {
+			$this->form_validation = $form_validation;
+		}
+		else {
+			$this->load->library('form_validation');
+		}
         
-        log_message('debug', 'CIDbModel Class Initialized');
-    }
-
-    //--------------------------------------------------------------------
-
-    //--------------------------------------------------------------------
-    // CRUD Methods
-    //--------------------------------------------------------------------
-
-    /**
-     * A simple way to grab the first result of a search only.
-     */
-    public function first()
-    {
-        $rows = $this->limit(1, 0)->find_all();
-
-        if (is_array($rows) && count($rows)) {
-            return $rows[0];
-        }
-
-        return $rows;
-    }
-
-    //--------------------------------------------------------------------
-
-
-    /**
-     * Finds a single record based on it's primary key. Will ignore deleted rows.
-     *
-     * @param  mixed $id The primary_key value of the object to retrieve.
-     * @return object
-     */
-    public function find($id)
-    {
-        $this->trigger('before_find', ['id' => $id, 'method' => 'find']);
-
-        // Ignore any soft-deleted rows
-        if ($this->soft_deletes) {
-            // We only need to modify the where statement if
-            // temp_with_deleted is false.
-            if ($this->temp_with_deleted !== true) {
-                $this->db->where($this->soft_delete_key, false);
-            }
-
-            $this->temp_with_deleted = false;
-        }
-
-        $this->db->where($this->primary_key, $id);
-        $row = $this->db->get($this->table_name);
-        $row = $this->temp_return_type == 'array' ? $row->row_array() : $row->row(0, $this->temp_return_type);
-
-        if ( ! empty($row))
-        {
-            $row = $this->trigger('after_find', ['id' => $id, 'method' => 'find', 'fields' => $row]);
-        }
-
-        // Reset our return type
-        $this->temp_return_type = $this->return_type;
-
-        return $row;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Fetch a single record based on an arbitrary WHERE call. Can be
-     * any valid value to $this->db->where(). Will not pull in deleted rows
-     * if using soft deletes.
-     *
-     * @return object
-     */
-    public function find_by()
-    {
-        $where = func_get_args();
-        $this->_set_where($where);
-
-        // Ignore any soft-deleted rows
-        if ($this->soft_deletes) {
-            // We only need to modify the where statement if
-            // temp_with_deleted is false.
-            if ($this->temp_with_deleted !== true) {
-                $this->db->where($this->soft_delete_key, false);
-            }
-
-            $this->temp_with_deleted = false;
-        }
-
-        $this->trigger('before_find', ['method' => 'find_by', 'fields' => $where]);
-
-        $row = $this->db->get($this->table_name);
-        $row = $this->temp_return_type == 'array' ? $row->row_array() : $row->row(0, $this->temp_return_type);
-
-        if ( ! empty($row))
-        {
-            $row = $this->trigger('after_find', ['method' => 'find_by', 'fields' => $row]);
-        }
-
-        // Reset our return type
-        $this->temp_return_type = $this->return_type;
-
-        return $row;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Retrieves a number of items based on an array of primary_values passed in.
-     *
-     * @param  array $values An array of primary key values to find.
-     *
-     * @return object or FALSE
-     */
-    public function find_many($values)
-    {
-        $this->db->where_in($this->primary_key, $values);
-
-        return $this->find_all();
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Retrieves a number of items based on an arbitrary WHERE call. Can be
-     * any set of parameters valid to $db->where.
-     *
-     * @return object or FALSE
-     */
-    public function find_many_by()
-    {
-        $where = func_get_args();
-        $this->_set_where($where);
-
-        return $this->find_all();
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Fetch all of the records in the table. Can be used with scoped calls
-     * to restrict the results.
-     *
-     * @return object or FALSE
-     */
-    public function find_all()
-    {
-        $this->trigger('before_find', ['method' => 'find_all']);
-
-        // Ignore any soft-deleted rows
-        if ($this->soft_deletes) {
-            // We only need to modify the where statement if
-            // temp_with_deleted is false.
-            if ($this->temp_with_deleted !== true) {
-                $this->db->where($this->soft_delete_key, false);
-            }
-
-            $this->temp_with_deleted = false;
-        }
-
-        $rows = $this->db->get($this->table_name);
-        $rows = $this->temp_return_type == 'array' ? $rows->result_array() : $rows->result($this->temp_return_type);
-
-        if (is_array($rows)) {
-            foreach ($rows as $key => &$row) {
-                $row = $this->trigger('after_find', ['method' => 'find_all', 'fields' => $row] );
-            }
-        }
-
-        // Reset our return type
-        $this->temp_return_type = $this->return_type;
-
-        return $rows;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Inserts data into the database.
-     *
-     * @param  array $data An array of key/value pairs to insert to database.
-     * @param  array $skip_validation If TRUE, will skip validation of data for this call only.
-     * @return mixed       The primary_key value of the inserted record, or FALSE.
-     */
-    public function insert($data, $skip_validation = null)
-    {
-        $skip_validation = is_null($skip_validation) ? $this->skip_validation : $skip_validation;
-
-        if ($skip_validation === FALSE) {
-            $data = $this->validate($data, 'insert', $skip_validation);
-        }
-
-        if ($data !== FALSE) {
-            $data = $this->trigger('before_insert', ['method' => 'insert', 'fields' => $data]);
-
-            $this->db->insert($this->table_name, $this->prep_data($data) );
-
-            if ($this->return_insert_id) {
-                $id = $this->db->insert_id();
-
-                $this->trigger('after_insert', ['id' => $id, 'fields' => $data, 'method' => 'insert']);
-
-                return $id;
-            }
-
-            return TRUE;
-        } else {
-            return FALSE;
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Inserts multiple rows into the database at once. Takes an associative
-     * array of value pairs.
-     *
-     * $data = array(
-     *     array(
-     *         'title' => 'My title'
-     *     ),
-     *     array(
-     *         'title'  => 'My Other Title'
-     *     )
-     * );
-     *
-     * @param  array $data An associate array of rows to insert
-     * @param  array $skip_validation If TRUE, will skip validation of data for this call only.
-     * @return bool
-     */
-    public function insert_batch($data, $skip_validation = null)
-    {
-        $skip_validation = is_null($skip_validation) ? $this->skip_validation : $skip_validation;
-
-        if ($skip_validation === FALSE) {
-            $data = $this->validate($data, 'insert', $skip_validation);
-        }
-
-        if ($data !== FALSE) {
-            $data['batch'] = true;
-            $data = $this->trigger('before_insert', ['method' => 'insert_batch', 'fields' => $data] );
-            unset($data['batch']);
-
-            return $this->db->insert_batch($this->table_name, $data);
-        } else {
-            return FALSE;
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Performs the SQL standard for a combined DELETE + INSERT, using
-     * PRIMARY and UNIQUE keys to determine which row to replace.
-     *
-     * See CI's documentation for the replace method. We simply wrap
-     * our validation and triggers around their method.
-     *
-     * @param $data
-     * @param null $skip_validation
-     * @return bool
-     */
-    public function replace($data, $skip_validation=null)
-    {
-        $skip_validation = is_null($skip_validation) ? $this->skip_validation : $skip_validation;
-
-        if ($skip_validation === FALSE) {
-            $data = $this->validate($data, 'insert', $skip_validation);
-        }
-
-        if ($data !== FALSE) {
-            $this->db->replace($this->table_name, $this->prep_data($data));
-
-            if ($this->return_insert_id) {
-                $id = $this->db->insert_id();
-
-                $this->trigger('after_insert', ['id' => $id, 'fields' => $data, 'method'=>'replace']);
-
-                return $id;
-            }
-
-            return TRUE;
-        } else {
-            return FALSE;
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-
-    /**
-     * Updates an existing record in the database.
-     *
-     * @param  mixed $id The primary_key value of the record to update.
-     * @param  array $data An array of value pairs to update in the record.
-     * @param  array $skip_validation If TRUE, will skip validation of data for this call only.
-     * @return bool
-     */
-    public function update($id, $data, $skip_validation = null)
-    {
-        $skip_validation = is_null($skip_validation) ? $this->skip_validation : $skip_validation;
-
-        if ($skip_validation === FALSE) {
-            $data = $this->validate($data);
-        }
-
-        // Will be false if it didn't validate.
-        if ($data !== FALSE) {
+		log_message('debug', 'CIDbModel Class Initialized');
+	}
+
+	//--------------------------------------------------------------------
+
+	//--------------------------------------------------------------------
+	// CRUD Methods
+	//--------------------------------------------------------------------
+
+	/**
+	 * A simple way to grab the first result of a search only.
+	 */
+	public function first()
+	{
+		$rows = $this->limit(1, 0)->find_all();
+
+		if (is_array($rows) && count($rows)) {
+			return $rows[0];
+		}
+
+		return $rows;
+	}
+
+	//--------------------------------------------------------------------
+
+
+	/**
+	 * Finds a single record based on it's primary key. Will ignore deleted rows.
+	 *
+	 * @param  mixed $id The primary_key value of the object to retrieve.
+	 * @return object
+	 */
+	public function find($id)
+	{
+		$this->trigger('before_find', ['id' => $id, 'method' => 'find']);
+
+		// Ignore any soft-deleted rows
+		if ($this->soft_deletes) {
+			// We only need to modify the where statement if
+			// temp_with_deleted is false.
+			if ($this->temp_with_deleted !== true) {
+				$this->db->where($this->soft_delete_key, false);
+			}
+
+			$this->temp_with_deleted = false;
+		}
+
+		$this->db->where($this->primary_key, $id);
+		$row = $this->db->get($this->table_name);
+		$row = $this->temp_return_type == 'array' ? $row->row_array() : $row->row(0, $this->temp_return_type);
+
+		if ( ! empty($row))
+		{
+			$row = $this->trigger('after_find', ['id' => $id, 'method' => 'find', 'fields' => $row]);
+		}
+
+		// Reset our return type
+		$this->temp_return_type = $this->return_type;
+
+		return $row;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Fetch a single record based on an arbitrary WHERE call. Can be
+	 * any valid value to $this->db->where(). Will not pull in deleted rows
+	 * if using soft deletes.
+	 *
+	 * @return object
+	 */
+	public function find_by()
+	{
+		$where = func_get_args();
+		$this->_set_where($where);
+
+		// Ignore any soft-deleted rows
+		if ($this->soft_deletes) {
+			// We only need to modify the where statement if
+			// temp_with_deleted is false.
+			if ($this->temp_with_deleted !== true) {
+				$this->db->where($this->soft_delete_key, false);
+			}
+
+			$this->temp_with_deleted = false;
+		}
+
+		$this->trigger('before_find', ['method' => 'find_by', 'fields' => $where]);
+
+		$row = $this->db->get($this->table_name);
+		$row = $this->temp_return_type == 'array' ? $row->row_array() : $row->row(0, $this->temp_return_type);
+
+		if ( ! empty($row))
+		{
+			$row = $this->trigger('after_find', ['method' => 'find_by', 'fields' => $row]);
+		}
+
+		// Reset our return type
+		$this->temp_return_type = $this->return_type;
+
+		return $row;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Retrieves a number of items based on an array of primary_values passed in.
+	 *
+	 * @param  array $values An array of primary key values to find.
+	 *
+	 * @return object or FALSE
+	 */
+	public function find_many($values)
+	{
+		$this->db->where_in($this->primary_key, $values);
+
+		return $this->find_all();
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Retrieves a number of items based on an arbitrary WHERE call. Can be
+	 * any set of parameters valid to $db->where.
+	 *
+	 * @return object or FALSE
+	 */
+	public function find_many_by()
+	{
+		$where = func_get_args();
+		$this->_set_where($where);
+
+		return $this->find_all();
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Fetch all of the records in the table. Can be used with scoped calls
+	 * to restrict the results.
+	 *
+	 * @return object or FALSE
+	 */
+	public function find_all()
+	{
+		$this->trigger('before_find', ['method' => 'find_all']);
+
+		// Ignore any soft-deleted rows
+		if ($this->soft_deletes) {
+			// We only need to modify the where statement if
+			// temp_with_deleted is false.
+			if ($this->temp_with_deleted !== true) {
+				$this->db->where($this->soft_delete_key, false);
+			}
+
+			$this->temp_with_deleted = false;
+		}
+
+		$rows = $this->db->get($this->table_name);
+		$rows = $this->temp_return_type == 'array' ? $rows->result_array() : $rows->result($this->temp_return_type);
+
+		if (is_array($rows)) {
+			foreach ($rows as $key => &$row) {
+				$row = $this->trigger('after_find', ['method' => 'find_all', 'fields' => $row] );
+			}
+		}
+
+		// Reset our return type
+		$this->temp_return_type = $this->return_type;
+
+		return $rows;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Inserts data into the database.
+	 *
+	 * @param  array $data An array of key/value pairs to insert to database.
+	 * @param  array $skip_validation If TRUE, will skip validation of data for this call only.
+	 * @return mixed       The primary_key value of the inserted record, or FALSE.
+	 */
+	public function insert($data, $skip_validation = null)
+	{
+		$skip_validation = is_null($skip_validation) ? $this->skip_validation : $skip_validation;
+
+		if ($skip_validation === FALSE) {
+			$data = $this->validate($data, 'insert', $skip_validation);
+		}
+
+		if ($data !== FALSE) {
+			$data = $this->trigger('before_insert', ['method' => 'insert', 'fields' => $data]);
+
+			$this->db->insert($this->table_name, $this->prep_data($data) );
+
+			if ($this->return_insert_id) {
+				$id = $this->db->insert_id();
+
+				$this->trigger('after_insert', ['id' => $id, 'fields' => $data, 'method' => 'insert']);
+
+				return $id;
+			}
+
+			return TRUE;
+		} else {
+			return FALSE;
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Inserts multiple rows into the database at once. Takes an associative
+	 * array of value pairs.
+	 *
+	 * $data = array(
+	 *     array(
+	 *         'title' => 'My title'
+	 *     ),
+	 *     array(
+	 *         'title'  => 'My Other Title'
+	 *     )
+	 * );
+	 *
+	 * @param  array $data An associate array of rows to insert
+	 * @param  array $skip_validation If TRUE, will skip validation of data for this call only.
+	 * @return bool
+	 */
+	public function insert_batch($data, $skip_validation = null)
+	{
+		$skip_validation = is_null($skip_validation) ? $this->skip_validation : $skip_validation;
+
+		if ($skip_validation === FALSE) {
+			$data = $this->validate($data, 'insert', $skip_validation);
+		}
+
+		if ($data !== FALSE) {
+			$data['batch'] = true;
+			$data = $this->trigger('before_insert', ['method' => 'insert_batch', 'fields' => $data] );
+			unset($data['batch']);
+
+			return $this->db->insert_batch($this->table_name, $data);
+		} else {
+			return FALSE;
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Performs the SQL standard for a combined DELETE + INSERT, using
+	 * PRIMARY and UNIQUE keys to determine which row to replace.
+	 *
+	 * See CI's documentation for the replace method. We simply wrap
+	 * our validation and triggers around their method.
+	 *
+	 * @param $data
+	 * @param null $skip_validation
+	 * @return bool
+	 */
+	public function replace($data, $skip_validation=null)
+	{
+		$skip_validation = is_null($skip_validation) ? $this->skip_validation : $skip_validation;
+
+		if ($skip_validation === FALSE) {
+			$data = $this->validate($data, 'insert', $skip_validation);
+		}
+
+		if ($data !== FALSE) {
+			$this->db->replace($this->table_name, $this->prep_data($data));
+
+			if ($this->return_insert_id) {
+				$id = $this->db->insert_id();
+
+				$this->trigger('after_insert', ['id' => $id, 'fields' => $data, 'method'=>'replace']);
+
+				return $id;
+			}
+
+			return TRUE;
+		} else {
+			return FALSE;
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+
+	/**
+	 * Updates an existing record in the database.
+	 *
+	 * @param  mixed $id The primary_key value of the record to update.
+	 * @param  array $data An array of value pairs to update in the record.
+	 * @param  array $skip_validation If TRUE, will skip validation of data for this call only.
+	 * @return bool
+	 */
+	public function update($id, $data, $skip_validation = null)
+	{
+		$skip_validation = is_null($skip_validation) ? $this->skip_validation : $skip_validation;
+
+		if ($skip_validation === FALSE) {
+			$data = $this->validate($data);
+		}
+
+		// Will be false if it didn't validate.
+		if ($data !== FALSE) {
             
-            $data = $this->trigger('before_update', ['id' => $id, 'method' =>'update', 'fields' => $data] );
+			$data = $this->trigger('before_update', ['id' => $id, 'method' =>'update', 'fields' => $data] );
             
-            $this->db->where($this->primary_key, $id);
-            $this->db->set( $this->prep_data($data) );
-            $result = $this->db->update($this->table_name);
-
-            $this->trigger('after_update', ['id' => $id, 'fields' => $data, 'result' => $result, 'method' => 'update']);
-
-            return $result;
-        } else {
-            return FALSE;
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Updates multiple records in the database at once.
-     *
-     * $data = array(
-     *     array(
-     *         'title'  => 'My title',
-     *         'body'   => 'body 1'
-     *     ),
-     *     array(
-     *         'title'  => 'Another Title',
-     *         'body'   => 'body 2'
-     *     )
-     * );
-     *
-     * The $where_key should be the name of the column to match the record on.
-     * If $where_key == 'title', then each record would be matched on that
-     * 'title' value of the array. This does mean that the array key needs
-     * to be provided with each row's data.
-     *
-     * @param  array $data An associate array of row data to update.
-     * @param  string $where_key The column name to match on.
-     * @return bool
-     */
-    public function update_batch($data, $where_key)
-    {
-        foreach ($data as &$row) {
-            $row = $this->trigger('before_update', ['method' => 'update_batch', 'fields' => $row] );
-        }
-
-        $result = $this->db->update_batch($this->table_name, $data, $where_key);
-
-        foreach ($data as &$row) {
-            $this->trigger('after_update', ['fields' => $data, 'result' => $result, 'method' => 'update_batch']);
-        }
-
-        return $result;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Updates many records by an array of ids.
-     *
-     * While update_batch() allows modifying multiple, arbitrary rows of data
-     * on each row, update_many() sets the same values for each row.
-     *
-     * $ids = array(1, 2, 3, 5, 12);
-     * $data = array(
-     *     'deleted_by' => 1
-     * );
-     *
-     * $this->model->update_many($ids, $data);
-     *
-     * @param  array $ids An array of primary_key values to update.
-     * @param  array $data An array of value pairs to modify in each row.
-     * @param  array $skip_validation If TRUE, will skip validation of data for this call only.
-     * @return bool
-     */
-    public function update_many($ids, $data, $skip_validation = null)
-    {
-        if (!is_array($ids) || count($ids) == 0) return NULL;
-
-        $skip_validation = is_null($skip_validation) ? $this->skip_validation : $skip_validation;
-
-        if ($skip_validation === FALSE) {
-            $data = $this->validate($data, 'update', $skip_validation);
-        }
-
-        $data = $this->trigger('before_update', ['ids' => $ids, 'method' => 'update_many', 'fields' => $data]);
-
-        // Will be false if it didn't validate.
-        if ($data !== FALSE) {
-            $this->db->where_in($this->primary_key, $ids);
-            $this->db->set($data);
-            $result = $this->db->update($this->table_name);
-
-            $this->trigger('after_update', ['ids' => $ids, 'fields' => $data, 'result'=>$result, 'method' => 'update_many']);
-
-            return $result;
-        } else {
-            return FALSE;
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Update records in the database using a standard WHERE clause.
-     *
-     * Your last parameter should be the $data array with values to update
-     * on the rows. Any additional parameters should be provided to make up
-     * a typical WHERE clause. This could be a single array, or a column name
-     * and a value.
-     *
-     * $data = array('deleted_by' => 1);
-     * $wheres = array('user_id' => 15);
-     *
-     * $this->update_by($wheres, $data);
-     * $this->update_by('user_id', 15, $data);
-     *
-     * @param array $data An array of data pairs to update
-     * @param one or more WHERE-acceptable entries.
-     * @return bool
-     */
-    public function update_by()
-    {
-        $args = func_get_args();
-        $data = array_pop($args);
-        $this->_set_where($args);
-
-        $data = $this->trigger('before_update', ['method' => 'update_by', 'fields' => $data]);
-
-        // Will be false if it didn't validate.
-        if ($this->validate($data) !== FALSE) {
-            $this->db->set( $this->prep_data($data) );
-            $result = $this->db->update($this->table_name);
-
-            $this->trigger('after_update', ['method' => 'update_by', 'fields' => $data, 'result' => $result] );
-
-            return $result;
-        } else {
-            return FALSE;
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Updates all records and sets the value pairs passed in the array.
-     *
-     * @param  array $data An array of value pairs with the data to change.
-     * @param  array $skip_validation If TRUE, will skip validation of data for this call only.
-     * @return bool
-     */
-    public function update_all($data, $skip_validation = FALSE)
-    {
-        $data = $this->trigger('before_update', ['method' => 'update_all', 'fields' => $data] );
-
-        $skip_validation = is_null($skip_validation) ? $this->skip_validation : $skip_validation;
-
-        if ($skip_validation === FALSE) {
-            $data = $this->validate($data);
-        }
-
-        // Will be false if it didn't validate.
-        if ($data !== FALSE) {
-            $this->db->set( $this->prep_data($data) );
-            $result = $this->db->update($this->table_name);
-
-            $this->trigger('after_update', ['method' => 'update_all', 'fields' => $data, 'result' => $result] );
-
-            return $result;
-        } else {
-            return FALSE;
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Increments the value of field for a given row, selected by the
-     * primary key for the table.
-     *
-     * @param $id
-     * @param $field
-     * @param int $value
-     * @return mixed
-     */
-    public function increment($id, $field, $value=1)
-    {
-        $value = (int)abs($value);
-
-        $this->db->where($this->primary_key, $id);
-        $this->db->set($field, "{$field}+{$value}", false);
-
-        return $this->db->update($this->table_name);
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Increments the value of field for a given row, selected by the
-     * primary key for the table.
-     *
-     * @param $id
-     * @param $field
-     * @param int $value
-     * @return mixed
-     */
-    public function decrement($id, $field, $value=1)
-    {
-        $value = (int)abs($value);
-
-        $this->db->where($this->primary_key, $id);
-        $this->db->set($field, "{$field}-{$value}", false);
-
-        return $this->db->update($this->table_name);
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Deletes a row by it's primary key value.
-     *
-     * @param  mixed $id The primary key value of the row to delete.
-     * @return bool
-     */
-    public function delete($id)
-    {
-        $this->trigger('before_delete', ['id' => $id, 'method' => 'delete'] );
-
-        $this->db->where($this->primary_key, $id);
-
-        if ($this->soft_deletes) {
-            $sets = $this->log_user && is_object($this->authenticate)
-                ? array($this->soft_delete_key => 1, $this->deleted_by_field => $this->authenticate->id())
-                : array($this->soft_delete_key => 1);
-
-            $result = $this->db->update($this->table_name, $sets);
-        } // Hard Delete
-        else {
-            $result = $this->db->delete($this->table_name);
-        }
-
-        $this->trigger('after_delete', ['id' => $id, 'method' => 'delete', 'result' => $result] );
+			$this->db->where($this->primary_key, $id);
+			$this->db->set( $this->prep_data($data) );
+			$result = $this->db->update($this->table_name);
+
+			$this->trigger('after_update', ['id' => $id, 'fields' => $data, 'result' => $result, 'method' => 'update']);
+
+			return $result;
+		} else {
+			return FALSE;
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Updates multiple records in the database at once.
+	 *
+	 * $data = array(
+	 *     array(
+	 *         'title'  => 'My title',
+	 *         'body'   => 'body 1'
+	 *     ),
+	 *     array(
+	 *         'title'  => 'Another Title',
+	 *         'body'   => 'body 2'
+	 *     )
+	 * );
+	 *
+	 * The $where_key should be the name of the column to match the record on.
+	 * If $where_key == 'title', then each record would be matched on that
+	 * 'title' value of the array. This does mean that the array key needs
+	 * to be provided with each row's data.
+	 *
+	 * @param  array $data An associate array of row data to update.
+	 * @param  string $where_key The column name to match on.
+	 * @return bool
+	 */
+	public function update_batch($data, $where_key)
+	{
+		foreach ($data as &$row) {
+			$row = $this->trigger('before_update', ['method' => 'update_batch', 'fields' => $row] );
+		}
+
+		$result = $this->db->update_batch($this->table_name, $data, $where_key);
+
+		foreach ($data as &$row) {
+			$this->trigger('after_update', ['fields' => $data, 'result' => $result, 'method' => 'update_batch']);
+		}
+
+		return $result;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Updates many records by an array of ids.
+	 *
+	 * While update_batch() allows modifying multiple, arbitrary rows of data
+	 * on each row, update_many() sets the same values for each row.
+	 *
+	 * $ids = array(1, 2, 3, 5, 12);
+	 * $data = array(
+	 *     'deleted_by' => 1
+	 * );
+	 *
+	 * $this->model->update_many($ids, $data);
+	 *
+	 * @param  array $ids An array of primary_key values to update.
+	 * @param  array $data An array of value pairs to modify in each row.
+	 * @param  array $skip_validation If TRUE, will skip validation of data for this call only.
+	 * @return bool
+	 */
+	public function update_many($ids, $data, $skip_validation = null)
+	{
+		if (!is_array($ids) || count($ids) == 0) return NULL;
+
+		$skip_validation = is_null($skip_validation) ? $this->skip_validation : $skip_validation;
+
+		if ($skip_validation === FALSE) {
+			$data = $this->validate($data, 'update', $skip_validation);
+		}
+
+		$data = $this->trigger('before_update', ['ids' => $ids, 'method' => 'update_many', 'fields' => $data]);
+
+		// Will be false if it didn't validate.
+		if ($data !== FALSE) {
+			$this->db->where_in($this->primary_key, $ids);
+			$this->db->set($data);
+			$result = $this->db->update($this->table_name);
+
+			$this->trigger('after_update', ['ids' => $ids, 'fields' => $data, 'result'=>$result, 'method' => 'update_many']);
+
+			return $result;
+		} else {
+			return FALSE;
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Update records in the database using a standard WHERE clause.
+	 *
+	 * Your last parameter should be the $data array with values to update
+	 * on the rows. Any additional parameters should be provided to make up
+	 * a typical WHERE clause. This could be a single array, or a column name
+	 * and a value.
+	 *
+	 * $data = array('deleted_by' => 1);
+	 * $wheres = array('user_id' => 15);
+	 *
+	 * $this->update_by($wheres, $data);
+	 * $this->update_by('user_id', 15, $data);
+	 *
+	 * @param array $data An array of data pairs to update
+	 * @param one or more WHERE-acceptable entries.
+	 * @return bool
+	 */
+	public function update_by()
+	{
+		$args = func_get_args();
+		$data = array_pop($args);
+		$this->_set_where($args);
+
+		$data = $this->trigger('before_update', ['method' => 'update_by', 'fields' => $data]);
+
+		// Will be false if it didn't validate.
+		if ($this->validate($data) !== FALSE) {
+			$this->db->set( $this->prep_data($data) );
+			$result = $this->db->update($this->table_name);
+
+			$this->trigger('after_update', ['method' => 'update_by', 'fields' => $data, 'result' => $result] );
+
+			return $result;
+		} else {
+			return FALSE;
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Updates all records and sets the value pairs passed in the array.
+	 *
+	 * @param  array $data An array of value pairs with the data to change.
+	 * @param  array $skip_validation If TRUE, will skip validation of data for this call only.
+	 * @return bool
+	 */
+	public function update_all($data, $skip_validation = FALSE)
+	{
+		$data = $this->trigger('before_update', ['method' => 'update_all', 'fields' => $data] );
+
+		$skip_validation = is_null($skip_validation) ? $this->skip_validation : $skip_validation;
+
+		if ($skip_validation === FALSE) {
+			$data = $this->validate($data);
+		}
+
+		// Will be false if it didn't validate.
+		if ($data !== FALSE) {
+			$this->db->set( $this->prep_data($data) );
+			$result = $this->db->update($this->table_name);
+
+			$this->trigger('after_update', ['method' => 'update_all', 'fields' => $data, 'result' => $result] );
+
+			return $result;
+		} else {
+			return FALSE;
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Increments the value of field for a given row, selected by the
+	 * primary key for the table.
+	 *
+	 * @param $id
+	 * @param $field
+	 * @param int $value
+	 * @return mixed
+	 */
+	public function increment($id, $field, $value=1)
+	{
+		$value = (int)abs($value);
+
+		$this->db->where($this->primary_key, $id);
+		$this->db->set($field, "{$field}+{$value}", false);
+
+		return $this->db->update($this->table_name);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Increments the value of field for a given row, selected by the
+	 * primary key for the table.
+	 *
+	 * @param $id
+	 * @param $field
+	 * @param int $value
+	 * @return mixed
+	 */
+	public function decrement($id, $field, $value=1)
+	{
+		$value = (int)abs($value);
+
+		$this->db->where($this->primary_key, $id);
+		$this->db->set($field, "{$field}-{$value}", false);
+
+		return $this->db->update($this->table_name);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Deletes a row by it's primary key value.
+	 *
+	 * @param  mixed $id The primary key value of the row to delete.
+	 * @return bool
+	 */
+	public function delete($id)
+	{
+		$this->trigger('before_delete', ['id' => $id, 'method' => 'delete'] );
+
+		$this->db->where($this->primary_key, $id);
+
+		if ($this->soft_deletes) {
+			$sets = $this->log_user && is_object($this->authenticate)
+				? array($this->soft_delete_key => 1, $this->deleted_by_field => $this->authenticate->id())
+				: array($this->soft_delete_key => 1);
+
+			$result = $this->db->update($this->table_name, $sets);
+		} // Hard Delete
+		else {
+			$result = $this->db->delete($this->table_name);
+		}
+
+		$this->trigger('after_delete', ['id' => $id, 'method' => 'delete', 'result' => $result] );
+
+		return $result;
+	}
+
+	//--------------------------------------------------------------------
+
+	public function delete_by()
+	{
+		$where = func_get_args();
+		$this->_set_where($where);
+
+		$where = $this->trigger('before_delete', ['method' => 'delete_by', 'fields' => $where]);
+
+		if ($this->soft_deletes) {
+			$sets = $this->log_user && is_object($this->authenticate)
+				? array($this->soft_delete_key => 1, $this->deleted_by_field => $this->authenticate->id())
+				: array($this->soft_delete_key => 1);
+
+			$result = $this->db->update($this->table_name, $sets);
+		} else {
+			$result = $this->db->delete($this->table_name);
+		}
+
+		$this->trigger('after_delete', ['method' => 'delete_by', 'fields' => $where, 'result' => $result] );
+
+		return $result;
+	}
+
+	//--------------------------------------------------------------------
+
+	public function delete_many($ids)
+	{
+		if (!is_array($ids) || count($ids) == 0) return NULL;
+
+		$ids = $this->trigger('before_delete', ['ids' => $ids, 'method' => 'delete_many'] );
+
+		$this->db->where_in($this->primary_key, $ids);
+
+		if ($this->soft_deletes) {
+			$sets = $this->log_user && is_object($this->authenticate)
+				? array($this->soft_delete_key => 1, $this->deleted_by_field => $this->authenticate->id())
+				: array($this->soft_delete_key => 1);
+
+			$result = $this->db->update($this->table_name, $sets);
+		} else {
+			$result = $this->db->delete($this->table_name);
+		}
+
+		$this->trigger('after_delete', ['ids' => $ids, 'method' => 'delete_many', 'result' => $result]);
 
-        return $result;
-    }
+		return $result;
+	}
+
+	//--------------------------------------------------------------------
+
+	//--------------------------------------------------------------------
+	// Scope Methods
+	//--------------------------------------------------------------------
+
+	/**
+	 * Sets the value of the soft deletes flag.
+	 *
+	 * @param  boolean $val If TRUE, should perform a soft delete. If FALSE, a hard delete.
+	 */
+	public function soft_delete($val = TRUE)
+	{
+		$this->soft_deletes = $val;
 
-    //--------------------------------------------------------------------
-
-    public function delete_by()
-    {
-        $where = func_get_args();
-        $this->_set_where($where);
-
-        $where = $this->trigger('before_delete', ['method' => 'delete_by', 'fields' => $where]);
-
-        if ($this->soft_deletes) {
-            $sets = $this->log_user && is_object($this->authenticate)
-                ? array($this->soft_delete_key => 1, $this->deleted_by_field => $this->authenticate->id())
-                : array($this->soft_delete_key => 1);
-
-            $result = $this->db->update($this->table_name, $sets);
-        } else {
-            $result = $this->db->delete($this->table_name);
-        }
-
-        $this->trigger('after_delete', ['method' => 'delete_by', 'fields' => $where, 'result' => $result] );
-
-        return $result;
-    }
-
-    //--------------------------------------------------------------------
-
-    public function delete_many($ids)
-    {
-        if (!is_array($ids) || count($ids) == 0) return NULL;
-
-        $ids = $this->trigger('before_delete', ['ids' => $ids, 'method' => 'delete_many'] );
-
-        $this->db->where_in($this->primary_key, $ids);
-
-        if ($this->soft_deletes) {
-            $sets = $this->log_user && is_object($this->authenticate)
-                ? array($this->soft_delete_key => 1, $this->deleted_by_field => $this->authenticate->id())
-                : array($this->soft_delete_key => 1);
-
-            $result = $this->db->update($this->table_name, $sets);
-        } else {
-            $result = $this->db->delete($this->table_name);
-        }
-
-        $this->trigger('after_delete', ['ids' => $ids, 'method' => 'delete_many', 'result' => $result]);
-
-        return $result;
-    }
-
-    //--------------------------------------------------------------------
-
-    //--------------------------------------------------------------------
-    // Scope Methods
-    //--------------------------------------------------------------------
-
-    /**
-     * Sets the value of the soft deletes flag.
-     *
-     * @param  boolean $val If TRUE, should perform a soft delete. If FALSE, a hard delete.
-     */
-    public function soft_delete($val = TRUE)
-    {
-        $this->soft_deletes = $val;
-
-        return $this;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Temporarily sets our return type to an array.
-     */
-    public function as_array()
-    {
-        $this->temp_return_type = 'array';
-
-        return $this;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Temporarily sets our return type to an object.
-     *
-     * If $class is provided, the rows will be returned as objects that
-     * are instances of that class. $class MUST be an fully qualified
-     * class name, meaning that it must include the namespace, if applicable.
-     *
-     * @param string $class
-     * @return $this
-     */
-    public function as_object($class=null)
-    {
-        $this->temp_return_type = ! empty($class) ? $class : 'object';
-
-        return $this;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Also fetches deleted items for this request only.
-     */
-    public function with_deleted()
-    {
-        $this->temp_with_deleted = TRUE;
-
-        return $this;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Returns whether the current setup will return
-     * soft deleted rows.
-     *
-     * @return bool
-     */
-    public function get_with_deleted()
-    {
-        return $this->temp_with_deleted;
-    }
-
-    //--------------------------------------------------------------------
-
-
-    /**
-     * Sets the $skip_validation parameter.
-     *
-     * @param bool $skip
-     * @return $this
-     */
-    public function skip_validation($skip = true)
-    {
-        $this->skip_validation = $skip;
-
-        return $this;
-    }
-
-    //--------------------------------------------------------------------
-
-
-    //--------------------------------------------------------------------
-    // Utility Methods
-    //--------------------------------------------------------------------
-
-    /**
-     * Counts number of rows modified by an arbitrary WHERE call.
-     * @return INT
-     */
-    public function count_by()
-    {
-        $where = func_get_args();
-        $this->_set_where($where);
-
-        return $this->db->count_all_results($this->table_name);
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Counts total number of records, disregarding any previous conditions.
-     *
-     * @return int
-     */
-    public function count_all()
-    {
-        return $this->db->count_all($this->table_name);
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Getter for the table name.
-     *
-     * @return string The name of the table used by this class.
-     */
-    public function table()
-    {
-        return $this->table_name;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Set the return_insert_id value.
-     *
-     * @param  boolean $return If TRUE, insert will return the insert_id.
-     */
-    public function return_insert_id($return = true)
-    {
-        $this->return_insert_id = (bool)$return;
-
-        return $this;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * A convenience method to return only a single field of the specified row.
-     *
-     * @param mixed $id The primary_key value to match against.
-     * @param string $field The field to search for.
-     *
-     * @return bool|mixed The value of the field.
-     */
-    public function get_field($id = NULL, $field = '')
-    {
-        $this->db->select($field);
-        $this->db->where($this->primary_key, $id);
-        $query = $this->db->get($this->table_name);
-
-        if ($query && $query->num_rows() > 0) {
-            return $query->row()->$field;
-        }
-
-        return FALSE;
-
-    }
-
-    //---------------------------------------------------------------
-
-    /**
-     * Checks whether a field/value pair exists within the table.
-     *
-     * @param string $field The field to search for.
-     * @param string $value The value to match $field against.
-     *
-     * @return bool TRUE/FALSE
-     */
-    public function is_unique($field, $value)
-    {
-        $this->db->where($field, $value);
-        $query = $this->db->get($this->table_name);
-
-        if ($query && $query->num_rows() == 0) {
-            return TRUE;
-        }
-
-        return FALSE;
-
-    }
-
-    //---------------------------------------------------------------
-
-    /**
-     * Adds a field to the protected_attributes array.
-     *
-     * @param $field
-     *
-     * @return mixed
-     */
-    public function protect($field)
-    {
-        $this->protected_attributes[] = $field;
-
-        return $this;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Get the field names for this model's table.
-     *
-     * Returns the model's database fields stored in $this->fields
-     * if set, else it tries to retrieve the field list from
-     * $this->db->list_fields($this->table_name);
-     *
-     * @return array    Returns the database fields for this model
-     */
-    public function get_fields()
-    {
-        if (empty($this->fields)) {
-            $this->fields = $this->db->list_fields($this->table_name);
-        }
-
-        return $this->fields;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Extracts the model's fields (except the key and those handled by
-     * Observers) from the $post_data and returns an array of name => value pairs
-     *
-     * @param Array $post_data The post data, usually $this->input->post() when called from the controller
-     *
-     * @return Array    An array of name => value pairs containing the data for the model's fields
-     */
-    public function prep_data($post_data)
-    {
-        $data = array();
-        $skippedFields = array();
-
-        if (empty($post_data))
-        {
-            return [];
-        }
-
-        // Though the model doesn't support multiple keys well, $this->key
-        // could be an array or a string...
-        $skippedFields = array_merge($skippedFields, (array)$this->primary_key);
-
-        // Remove any protected attributes
-        $skippedFields = array_merge($skippedFields, $this->protected_attributes);
-
-        $fields = $this->get_fields();
-
-        // If the field is the primary key, one of the created/modified/deleted
-        // fields, or has not been set in the $post_data, skip it
-        foreach ($post_data as $field => $value) {
-            if (in_array($field, $skippedFields) ||
-                ! in_array($field, $fields))
-            {
-                continue;
-            }
-
-            $data[$field] = $value;
-        }
-
-        return $data;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Returns the last query string, if available. Simply a wrapper for
-     * CodeIgniter's database method of the same name.
-     *
-     * @return string
-     */
-    public function last_query ()
-    {
-        return $this->db->last_query();
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Returns the elapsed time for the last query that was executed, if
-     * available, or NULL if not available, like if debug mode is off.
-     *
-     * @return mixed
-     */
-    public function last_query_time ()
-    {
-        $times = $this->db->query_times;
-
-        if (! is_array($this->db->query_times) || ! count($this->db->query_times))
-        {
-            return null;
-        }
-
-        return end($times);
-    }
-
-    //--------------------------------------------------------------------
-
-    //--------------------------------------------------------------------
-    // Observers
-    //--------------------------------------------------------------------
-
-    /**
-     * Sets the created on date for the object based on the
-     * current date/time and date_format. Will not overwrite existing.
-     *
-     * @param array $row The array of data to be inserted
-     *
-     * @return array
-     */
-    public function created_on($row)
-    {
-        if (empty($row['fields']))
-        {
-            return null;
-        }
-
-        $row = $row['fields'];
-
-        // Created_on
-        if (! array_key_exists($this->created_field, $row))
-        {
-            $row[$this->created_field] = $this->set_date();
-        }
-
-        // Created by
-        if ($this->log_user && ! array_key_exists($this->created_by_field, $row) && is_object($this->authenticate))
-        {
-            // If you're here because of an error with $this->authenticate
-            // not being available, it's likely due to you not using
-            // the AuthTrait and/or setting log_user after model is instantiated.
-            $row[$this->created_by_field] = (int)$this->authenticate->id();
-        }
-
-        return $row;
-    } // end created_on()
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Sets the modified_on date for the object based on the
-     * current date/time and date_format. Will not overwrite existing.
-     *
-     * @param array $row The array of data to be inserted
-     *
-     * @return array
-     */
-    public function modified_on($row)
-    {
-        if (empty($row['fields']))
-        {
-            return null;
-        }
-
-        $row = $row['fields'];
-
-        if (is_array($row) && ! array_key_exists($this->modified_field, $row))
-        {
-            $row[$this->modified_field] = $this->set_date();
-        }
-
-        // Modified by
-        if ($this->log_user && ! array_key_exists($this->modified_by_field, $row) && is_object($this->authenticate))
-        {
-            // If you're here because of an error with $this->authenticate
-            // not being available, it's likely due to you not using
-            // the AuthTrait and/or setting log_user after model is instantiated.
-            $row[$this->modified_by_field] = $this->authenticate->id();
-        }
-
-        return $row;
-    }
-
-    //--------------------------------------------------------------------
-
-    //--------------------------------------------------------------------
-    // Internal Methods
-    //--------------------------------------------------------------------
-
-    /**
-     * Set WHERE parameters
-     */
-    protected function _set_where($params)
-    {
-        if (count($params) == 1) {
-            $this->db->where($params[0]);
-        } else {
-            $this->db->where($params[0], $params[1]);
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Triggers a model-specific event and call each of it's observers.
-     *
-     * @param string $event The name of the event to trigger
-     * @param mixed $data The data to be passed to the callback functions.
-     *
-     * @return mixed
-     */
-    public function trigger($event, $data = false)
-    {
-        if (! isset($this->$event) || ! is_array($this->$event))
-        {
-            if (isset($data['fields']))
-            {
-                return $data['fields'];
-            }
-
-            return $data;
-        }
-
-        foreach ($this->$event as $method)
-        {
-            if (strpos($method, '('))
-            {
-                preg_match('/([a-zA-Z0-9\_\-]+)(\(([a-zA-Z0-9\_\-\., ]+)\))?/', $method, $matches);
-                $this->callback_parameters = explode(',', $matches[3]);
-            }
-
-            $data = call_user_func_array(array($this, $method), array($data));
-        }
-
-        // In case no method called or method returned
-        // the entire data array, we typically just need the $fields
-        if (isset($data['fields']))
-        {
-            return $data['fields'];
-        }
-
-        // A few methods might need to return 'ids'
-        if (isset($data['ids']))
-        {
-            return $data['ids'];
-        }
-
-        return $data;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Validates the data passed into it based upon the form_validation rules
-     * setup in the $this->validate property.
-     *
-     * If $type == 'insert', any additional rules in the class var $insert_validate_rules
-     * for that field will be added to the rules.
-     *
-     * @param  array $data An array of validation rules
-     * @param  string $type Either 'update' or 'insert'.
-     * @return array/bool       The original data or FALSE
-     */
-    public function validate($data, $type = 'update', $skip_validation = null)
-    {
-        $skip_validation = is_null($skip_validation) ? $this->skip_validation : $skip_validation;
-
-        if ($skip_validation) {
-            return $data;
-        }
-
-        // We need the database to be loaded up at this point in case
-        // we want to use callbacks that hit the database.
-        if (empty($this->db))
-        {
-            $this->load->database();
-        }
-
-        if (!empty($this->validation_rules)) {
-            $this->form_validation->set_data($data);
-
-            if (is_array($this->validation_rules)) {
-                // Any insert additions?
-                if ($type == 'insert'
-                    && !empty($this->insert_validate_rules)
-                    && is_array($this->insert_validate_rules)
-                ) {
-                    foreach ($this->validation_rules as &$row) {
-                        if (isset($this->insert_validate_rules[$row['field']])) {
-                            $row ['rules'] .= '|' . $this->insert_validate_rules[$row['field']];
-                        }
-                    }
-                }
-
-                $this->form_validation->set_rules($this->validation_rules);
-
-                if ($this->form_validation->run('', $this) === TRUE) {
-                    return $data;
-                } else {
-                    return FALSE;
-                }
-            } else {
-                if ($this->form_validation->run($this->validate, $this) === TRUE) {
-                    return $data;
-                } else {
-                    return FALSE;
-                }
-            }
-        } else {
-            return $data;
-        }
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Protect attributes by removing them from $row array. Useful for
-     * removing id, or submit buttons names if you simply throw your $_POST
-     * array at your model. :)
-     *
-     * @param object /array $row The value pair item to remove.
-     */
-    public function protect_attributes($row)
-    {
-        foreach ($this->protected_attributes as $attr) {
-            if (is_object($row)) {
-                unset($row->$attr);
-            } else {
-                unset($row[$attr]);
-            }
-        }
-
-        return $row;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * A utility function to allow child models to use the type of
-     * date/time format that they prefer. This is primarily used for
-     * setting created_on and modified_on values, but can be used by
-     * inheriting classes.
-     *
-     * The available time formats are:
-     * * 'int'      - Stores the date as an integer timestamp.
-     * * 'datetime' - Stores the date and time in the SQL datetime format.
-     * * 'date'     - Stores teh date (only) in the SQL date format.
-     *
-     * @param mixed $user_date An optional PHP timestamp to be converted.
-     *
-     * @access protected
-     *
-     * @return int|null|string The current/user time converted to the proper format.
-     */
-    protected function set_date($user_date = NULL)
-    {
-        $curr_date = !empty($user_date) ? $user_date : time();
-
-        switch ($this->date_format) {
-            case 'int':
-                return $curr_date;
-                break;
-            case 'datetime':
-                return date('Y-m-d H:i:s', $curr_date);
-                break;
-            case 'date':
-                return date('Y-m-d', $curr_date);
-                break;
-        }
-
-    }//end set_date()
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Returns an array containing the 'code' and 'message' of the
-     * database's error, as provided by CI's database drivers.
-     *
-     * @return mixed
-     */
-    public function error($db_array_only=false)
-    {
-        // Send any validation errors if we have any.
-        if (function_exists('validation_errors') && validation_errors() && ! $db_array_only)
-        {
-            return validation_errors();
-        }
-
-        // No validation errors? Return the db error.
-        $error = $this->db->error();
-
-        if ($db_array_only)
-        {
-            return $error;
-        }
-
-        if (! empty($error['code']))
-        {
-            return "Database Error {$error['code']}: {$error['message']}.";
-        }
-
-        // No errors found.
-        return '';
-    }
-
-    //--------------------------------------------------------------------
-
-    //--------------------------------------------------------------------
-    // Magic Methods
-    //--------------------------------------------------------------------
-
-    /**
-     * __get magic
-     *
-     * Allows models to access CI's loaded classes using the same
-     * syntax as controllers.
-     *
-     * This is the same as what CI's model uses, but we keep it
-     * here since that's the ONLY thing that CI's model does.
-     *
-     * @param    string $key
-     */
-    public function __get($key)
-    {
-        // Give them first crack at any protected class vars
-        if (isset($this->$key))
-        {
-            return $this->$key;
-        }
-
-        // Debugging note:
-        //	If you're here because you're getting an error message
-        //	saying 'Undefined Property: system/core/Model.php', it's
-        //	most likely a typo in your model code.
-        return get_instance()->$key;
-    }
-
-    //--------------------------------------------------------------------
-
-    /**
-     * Provide direct access to any of CodeIgniter's DB methods but
-     * make it look like it's part of the class, purely for convenience.
-     *
-     * @param $name
-     * @param $params
-     */
-    public function __call($name, $params)
-    {
-        if (method_exists($this->db, $name))
-        {
-            call_user_func_array([$this->db, $name], $params);
-            return $this;
-        }
-    }
-
-    //--------------------------------------------------------------------
+		return $this;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Temporarily sets our return type to an array.
+	 */
+	public function as_array()
+	{
+		$this->temp_return_type = 'array';
+
+		return $this;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Temporarily sets our return type to an object.
+	 *
+	 * If $class is provided, the rows will be returned as objects that
+	 * are instances of that class. $class MUST be an fully qualified
+	 * class name, meaning that it must include the namespace, if applicable.
+	 *
+	 * @param string $class
+	 * @return $this
+	 */
+	public function as_object($class=null)
+	{
+		$this->temp_return_type = ! empty($class) ? $class : 'object';
+
+		return $this;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Also fetches deleted items for this request only.
+	 */
+	public function with_deleted()
+	{
+		$this->temp_with_deleted = TRUE;
+
+		return $this;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Returns whether the current setup will return
+	 * soft deleted rows.
+	 *
+	 * @return bool
+	 */
+	public function get_with_deleted()
+	{
+		return $this->temp_with_deleted;
+	}
+
+	//--------------------------------------------------------------------
+
+
+	/**
+	 * Sets the $skip_validation parameter.
+	 *
+	 * @param bool $skip
+	 * @return $this
+	 */
+	public function skip_validation($skip = true)
+	{
+		$this->skip_validation = $skip;
+
+		return $this;
+	}
+
+	//--------------------------------------------------------------------
+
+
+	//--------------------------------------------------------------------
+	// Utility Methods
+	//--------------------------------------------------------------------
+
+	/**
+	 * Counts number of rows modified by an arbitrary WHERE call.
+	 * @return INT
+	 */
+	public function count_by()
+	{
+		$where = func_get_args();
+		$this->_set_where($where);
+
+		return $this->db->count_all_results($this->table_name);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Counts total number of records, disregarding any previous conditions.
+	 *
+	 * @return int
+	 */
+	public function count_all()
+	{
+		return $this->db->count_all($this->table_name);
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Getter for the table name.
+	 *
+	 * @return string The name of the table used by this class.
+	 */
+	public function table()
+	{
+		return $this->table_name;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Set the return_insert_id value.
+	 *
+	 * @param  boolean $return If TRUE, insert will return the insert_id.
+	 */
+	public function return_insert_id($return = true)
+	{
+		$this->return_insert_id = (bool)$return;
+
+		return $this;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * A convenience method to return only a single field of the specified row.
+	 *
+	 * @param mixed $id The primary_key value to match against.
+	 * @param string $field The field to search for.
+	 *
+	 * @return bool|mixed The value of the field.
+	 */
+	public function get_field($id = NULL, $field = '')
+	{
+		$this->db->select($field);
+		$this->db->where($this->primary_key, $id);
+		$query = $this->db->get($this->table_name);
+
+		if ($query && $query->num_rows() > 0) {
+			return $query->row()->$field;
+		}
+
+		return FALSE;
+
+	}
+
+	//---------------------------------------------------------------
+
+	/**
+	 * Checks whether a field/value pair exists within the table.
+	 *
+	 * @param string $field The field to search for.
+	 * @param string $value The value to match $field against.
+	 *
+	 * @return bool TRUE/FALSE
+	 */
+	public function is_unique($field, $value)
+	{
+		$this->db->where($field, $value);
+		$query = $this->db->get($this->table_name);
+
+		if ($query && $query->num_rows() == 0) {
+			return TRUE;
+		}
+
+		return FALSE;
+
+	}
+
+	//---------------------------------------------------------------
+
+	/**
+	 * Adds a field to the protected_attributes array.
+	 *
+	 * @param $field
+	 *
+	 * @return mixed
+	 */
+	public function protect($field)
+	{
+		$this->protected_attributes[] = $field;
+
+		return $this;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Get the field names for this model's table.
+	 *
+	 * Returns the model's database fields stored in $this->fields
+	 * if set, else it tries to retrieve the field list from
+	 * $this->db->list_fields($this->table_name);
+	 *
+	 * @return array    Returns the database fields for this model
+	 */
+	public function get_fields()
+	{
+		if (empty($this->fields)) {
+			$this->fields = $this->db->list_fields($this->table_name);
+		}
+
+		return $this->fields;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Extracts the model's fields (except the key and those handled by
+	 * Observers) from the $post_data and returns an array of name => value pairs
+	 *
+	 * @param Array $post_data The post data, usually $this->input->post() when called from the controller
+	 *
+	 * @return Array    An array of name => value pairs containing the data for the model's fields
+	 */
+	public function prep_data($post_data)
+	{
+		$data = array();
+		$skippedFields = array();
+
+		if (empty($post_data))
+		{
+			return [];
+		}
+
+		// Though the model doesn't support multiple keys well, $this->key
+		// could be an array or a string...
+		$skippedFields = array_merge($skippedFields, (array)$this->primary_key);
+
+		// Remove any protected attributes
+		$skippedFields = array_merge($skippedFields, $this->protected_attributes);
+
+		$fields = $this->get_fields();
+
+		// If the field is the primary key, one of the created/modified/deleted
+		// fields, or has not been set in the $post_data, skip it
+		foreach ($post_data as $field => $value) {
+			if (in_array($field, $skippedFields) ||
+				! in_array($field, $fields))
+			{
+				continue;
+			}
+
+			$data[$field] = $value;
+		}
+
+		return $data;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Returns the last query string, if available. Simply a wrapper for
+	 * CodeIgniter's database method of the same name.
+	 *
+	 * @return string
+	 */
+	public function last_query ()
+	{
+		return $this->db->last_query();
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Returns the elapsed time for the last query that was executed, if
+	 * available, or NULL if not available, like if debug mode is off.
+	 *
+	 * @return mixed
+	 */
+	public function last_query_time ()
+	{
+		$times = $this->db->query_times;
+
+		if (! is_array($this->db->query_times) || ! count($this->db->query_times))
+		{
+			return null;
+		}
+
+		return end($times);
+	}
+
+	//--------------------------------------------------------------------
+
+	//--------------------------------------------------------------------
+	// Observers
+	//--------------------------------------------------------------------
+
+	/**
+	 * Sets the created on date for the object based on the
+	 * current date/time and date_format. Will not overwrite existing.
+	 *
+	 * @param array $row The array of data to be inserted
+	 *
+	 * @return array
+	 */
+	public function created_on($row)
+	{
+		if (empty($row['fields']))
+		{
+			return null;
+		}
+
+		$row = $row['fields'];
+
+		// Created_on
+		if (! array_key_exists($this->created_field, $row))
+		{
+			$row[$this->created_field] = $this->set_date();
+		}
+
+		// Created by
+		if ($this->log_user && ! array_key_exists($this->created_by_field, $row) && is_object($this->authenticate))
+		{
+			// If you're here because of an error with $this->authenticate
+			// not being available, it's likely due to you not using
+			// the AuthTrait and/or setting log_user after model is instantiated.
+			$row[$this->created_by_field] = (int)$this->authenticate->id();
+		}
+
+		return $row;
+	} // end created_on()
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Sets the modified_on date for the object based on the
+	 * current date/time and date_format. Will not overwrite existing.
+	 *
+	 * @param array $row The array of data to be inserted
+	 *
+	 * @return array
+	 */
+	public function modified_on($row)
+	{
+		if (empty($row['fields']))
+		{
+			return null;
+		}
+
+		$row = $row['fields'];
+
+		if (is_array($row) && ! array_key_exists($this->modified_field, $row))
+		{
+			$row[$this->modified_field] = $this->set_date();
+		}
+
+		// Modified by
+		if ($this->log_user && ! array_key_exists($this->modified_by_field, $row) && is_object($this->authenticate))
+		{
+			// If you're here because of an error with $this->authenticate
+			// not being available, it's likely due to you not using
+			// the AuthTrait and/or setting log_user after model is instantiated.
+			$row[$this->modified_by_field] = $this->authenticate->id();
+		}
+
+		return $row;
+	}
+
+	//--------------------------------------------------------------------
+
+	//--------------------------------------------------------------------
+	// Internal Methods
+	//--------------------------------------------------------------------
+
+	/**
+	 * Set WHERE parameters
+	 */
+	protected function _set_where($params)
+	{
+		if (count($params) == 1) {
+			$this->db->where($params[0]);
+		} else {
+			$this->db->where($params[0], $params[1]);
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Triggers a model-specific event and call each of it's observers.
+	 *
+	 * @param string $event The name of the event to trigger
+	 * @param mixed $data The data to be passed to the callback functions.
+	 *
+	 * @return mixed
+	 */
+	public function trigger($event, $data = false)
+	{
+		if (! isset($this->$event) || ! is_array($this->$event))
+		{
+			if (isset($data['fields']))
+			{
+				return $data['fields'];
+			}
+
+			return $data;
+		}
+
+		foreach ($this->$event as $method)
+		{
+			if (strpos($method, '('))
+			{
+				preg_match('/([a-zA-Z0-9\_\-]+)(\(([a-zA-Z0-9\_\-\., ]+)\))?/', $method, $matches);
+				$this->callback_parameters = explode(',', $matches[3]);
+			}
+
+			$data = call_user_func_array(array($this, $method), array($data));
+		}
+
+		// In case no method called or method returned
+		// the entire data array, we typically just need the $fields
+		if (isset($data['fields']))
+		{
+			return $data['fields'];
+		}
+
+		// A few methods might need to return 'ids'
+		if (isset($data['ids']))
+		{
+			return $data['ids'];
+		}
+
+		return $data;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Validates the data passed into it based upon the form_validation rules
+	 * setup in the $this->validate property.
+	 *
+	 * If $type == 'insert', any additional rules in the class var $insert_validate_rules
+	 * for that field will be added to the rules.
+	 *
+	 * @param  array $data An array of validation rules
+	 * @param  string $type Either 'update' or 'insert'.
+	 * @return array/bool       The original data or FALSE
+	 */
+	public function validate($data, $type = 'update', $skip_validation = null)
+	{
+		$skip_validation = is_null($skip_validation) ? $this->skip_validation : $skip_validation;
+
+		if ($skip_validation) {
+			return $data;
+		}
+
+		// We need the database to be loaded up at this point in case
+		// we want to use callbacks that hit the database.
+		if (empty($this->db))
+		{
+			$this->load->database();
+		}
+
+		if (!empty($this->validation_rules)) {
+			$this->form_validation->set_data($data);
+
+			if (is_array($this->validation_rules)) {
+				// Any insert additions?
+				if ($type == 'insert'
+					&& !empty($this->insert_validate_rules)
+					&& is_array($this->insert_validate_rules)
+				) {
+					foreach ($this->validation_rules as &$row) {
+						if (isset($this->insert_validate_rules[$row['field']])) {
+							$row ['rules'] .= '|' . $this->insert_validate_rules[$row['field']];
+						}
+					}
+				}
+
+				$this->form_validation->set_rules($this->validation_rules);
+
+				if ($this->form_validation->run('', $this) === TRUE) {
+					return $data;
+				} else {
+					return FALSE;
+				}
+			} else {
+				if ($this->form_validation->run($this->validate, $this) === TRUE) {
+					return $data;
+				} else {
+					return FALSE;
+				}
+			}
+		} else {
+			return $data;
+		}
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Protect attributes by removing them from $row array. Useful for
+	 * removing id, or submit buttons names if you simply throw your $_POST
+	 * array at your model. :)
+	 *
+	 * @param object /array $row The value pair item to remove.
+	 */
+	public function protect_attributes($row)
+	{
+		foreach ($this->protected_attributes as $attr) {
+			if (is_object($row)) {
+				unset($row->$attr);
+			} else {
+				unset($row[$attr]);
+			}
+		}
+
+		return $row;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * A utility function to allow child models to use the type of
+	 * date/time format that they prefer. This is primarily used for
+	 * setting created_on and modified_on values, but can be used by
+	 * inheriting classes.
+	 *
+	 * The available time formats are:
+	 * * 'int'      - Stores the date as an integer timestamp.
+	 * * 'datetime' - Stores the date and time in the SQL datetime format.
+	 * * 'date'     - Stores teh date (only) in the SQL date format.
+	 *
+	 * @param mixed $user_date An optional PHP timestamp to be converted.
+	 *
+	 * @access protected
+	 *
+	 * @return int|null|string The current/user time converted to the proper format.
+	 */
+	protected function set_date($user_date = NULL)
+	{
+		$curr_date = !empty($user_date) ? $user_date : time();
+
+		switch ($this->date_format) {
+			case 'int':
+				return $curr_date;
+				break;
+			case 'datetime':
+				return date('Y-m-d H:i:s', $curr_date);
+				break;
+			case 'date':
+				return date('Y-m-d', $curr_date);
+				break;
+		}
+
+	}//end set_date()
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Returns an array containing the 'code' and 'message' of the
+	 * database's error, as provided by CI's database drivers.
+	 *
+	 * @return mixed
+	 */
+	public function error($db_array_only=false)
+	{
+		// Send any validation errors if we have any.
+		if (function_exists('validation_errors') && validation_errors() && ! $db_array_only)
+		{
+			return validation_errors();
+		}
+
+		// No validation errors? Return the db error.
+		$error = $this->db->error();
+
+		if ($db_array_only)
+		{
+			return $error;
+		}
+
+		if (! empty($error['code']))
+		{
+			return "Database Error {$error['code']}: {$error['message']}.";
+		}
+
+		// No errors found.
+		return '';
+	}
+
+	//--------------------------------------------------------------------
+
+	//--------------------------------------------------------------------
+	// Magic Methods
+	//--------------------------------------------------------------------
+
+	/**
+	 * __get magic
+	 *
+	 * Allows models to access CI's loaded classes using the same
+	 * syntax as controllers.
+	 *
+	 * This is the same as what CI's model uses, but we keep it
+	 * here since that's the ONLY thing that CI's model does.
+	 *
+	 * @param    string $key
+	 */
+	public function __get($key)
+	{
+		// Give them first crack at any protected class vars
+		if (isset($this->$key))
+		{
+			return $this->$key;
+		}
+
+		// Debugging note:
+		//	If you're here because you're getting an error message
+		//	saying 'Undefined Property: system/core/Model.php', it's
+		//	most likely a typo in your model code.
+		return get_instance()->$key;
+	}
+
+	//--------------------------------------------------------------------
+
+	/**
+	 * Provide direct access to any of CodeIgniter's DB methods but
+	 * make it look like it's part of the class, purely for convenience.
+	 *
+	 * @param $name
+	 * @param $params
+	 */
+	public function __call($name, $params)
+	{
+		if (method_exists($this->db, $name))
+		{
+			call_user_func_array([$this->db, $name], $params);
+			return $this;
+		}
+	}
+
+	//--------------------------------------------------------------------
 
 
 }

myth/CIModules/auth/controllers/Auth.php

Indentation +234 added lines, -234 removed lines

@@ -36,225 +36,225 @@ 
 class Auth extends \Myth\Controllers\ThemedController
 {
 
-    public function __construct()
-    {
-        parent::__construct();
-
-        $this->config->load('auth');
-        $this->lang->load('auth');
-        $this->load->library('session');
-    }
-
-    //--------------------------------------------------------------------
-
-    public function login()
-    {
-        $this->load->helper('form');
-
-        $auth = new LocalAuthentication();
-        $this->load->model('user_model');
-        $auth->useModel($this->user_model);
-
-        $redirect_url = $this->session->userdata('redirect_url');
-
-        // No need to login again if they are already logged in...
-        if ($auth->isLoggedIn())
-        {
-            unset($_SESSION['redirect_url']);
-            redirect($redirect_url);
-        }
-
-        if ($this->input->post())
-        {
-            $post_data = [
-                'email'    => $this->input->post('email'),
-                'password' => $this->input->post('password')
-            ];
-
-            $remember = (bool)$this->input->post('remember');
-
-            if ($auth->login($post_data, $remember))
-            {
-	            // Is the user being forced to reset their password?
-	            if ($auth->user()['force_pass_reset'] == 1)
-	            {
-		            redirect( Route::named('change_pass') );
-	            }
-
-                unset($_SESSION['redirect_url']);
-                $this->setMessage(lang('auth.did_login'), 'success');
-                redirect($redirect_url);
-            }
-
-            $this->setMessage(lang('auth.invalid_user'), 'danger');
-        }
-
-        $this->themer->setLayout('login');
-        $this->render();
-    }
-
-    //--------------------------------------------------------------------
-
-    public function logout()
-    {
-        $auth = new LocalAuthentication();
-        $this->load->model('user_model');
-        $auth->useModel($this->user_model);
-
-        if ($auth->isLoggedIn())
-        {
-            $auth->logout();
-
-            $this->setMessage(lang('auth.did_logout'), 'success');
-        }
-
-        redirect('/');
-    }
-
-    //--------------------------------------------------------------------
-
-    public function register()
-    {
-        $this->load->helper('form');
-
-        if ($this->input->post())
-        {
-            $auth = new LocalAuthentication();
-            $this->load->model('user_model');
-            $auth->useModel($this->user_model);
-
-            $post_data = [
-                'first_name'   => $this->input->post('first_name'),
-                'last_name'    => $this->input->post('last_name'),
-                'email'        => $this->input->post('email'),
-                'username'     => $this->input->post('username'),
-                'password'     => $this->input->post('password'),
-                'pass_confirm' => $this->input->post('pass_confirm')
-            ];
-
-            if ($auth->registerUser($post_data))
-            {
-                $this->setMessage(lang('auth.did_register'), 'success');
-                redirect( Route::named('login') );
-            }
-            else
-            {
-                $this->setMessage($auth->error(), 'danger');
-            }
-        }
-
-        $this->addScript('register.js');
-        $this->themer->setLayout('login');
-        $this->render();
-    }
-
-    //--------------------------------------------------------------------
-
-    public function activate_user()
-    {
-        $this->load->helper('form');
-
-        if ($this->input->post())
-        {
-            $auth = new LocalAuthentication();
-            $this->load->model('user_model');
-            $auth->useModel($this->user_model);
-
-            $post_data = [
-                  'email' => $this->input->post('email'),
-                  'code'  => $this->input->post('code')
-            ];
-
-            if ($auth->activateUser($post_data))
-            {
-                $this->setMessage(lang('auth.did_activate'), 'success');
-                redirect( Route::named('login') );
-            }
-            else
-            {
-                $this->setMessage($auth->error(), 'danger');
-            }
-        }
-
-        $data = [
-            'email' => $this->input->get('e'),
-            'code'  => $this->input->get('code')
-        ];
-
-        $this->themer->setLayout('login');
-        $this->render($data);
-    }
-
-    //--------------------------------------------------------------------
-
-
-    public function forgot_password()
-    {
-        $this->load->helper('form');
-
-        if ($this->input->post())
-        {
-            $auth = new LocalAuthentication();
-            $this->load->model('user_model');
-            $auth->useModel($this->user_model);
-
-            if ($auth->remindUser($this->input->post('email')))
-            {
-                $this->setMessage(lang('auth.send_success'), 'success');
-                redirect( Route::named('reset_pass') );
-            }
-            else
-            {
-                $this->setMessage($auth->error(), 'danger');
-            }
-        }
-
-        $this->themer->setLayout('login');
-        $this->render();
-    }
-
-    //--------------------------------------------------------------------
-
-    public function reset_password()
-    {
-        $this->load->helper('form');
-
-        if ($this->input->post())
-        {
-            $auth = new LocalAuthentication();
-            $this->load->model('user_model');
-            $auth->useModel($this->user_model);
-
-            $credentials = [
-                'email' => $this->input->post('email'),
-                'code'  => $this->input->post('code')
-            ];
-
-            $password     = $this->input->post('password');
-            $pass_confirm = $this->input->post('pass_confirm');
-
-            if ($auth->resetPassword($credentials, $password, $pass_confirm))
-            {
-                $this->setMessage(lang('auth.new_password_success'), 'success');
-                redirect( Route::named('login') );
-            }
-            else
-            {
-                $this->setMessage($auth->error(), 'danger');
-            }
-        }
-
-        $data = [
-            'email' => $this->input->get('e'),
-            'code'  => $this->input->get('code')
-        ];
-
-        $this->addScript('register.js');
-        $this->themer->setLayout('login');
-        $this->render($data);
-    }
-
-    //--------------------------------------------------------------------
+	public function __construct()
+	{
+		parent::__construct();
+
+		$this->config->load('auth');
+		$this->lang->load('auth');
+		$this->load->library('session');
+	}
+
+	//--------------------------------------------------------------------
+
+	public function login()
+	{
+		$this->load->helper('form');
+
+		$auth = new LocalAuthentication();
+		$this->load->model('user_model');
+		$auth->useModel($this->user_model);
+
+		$redirect_url = $this->session->userdata('redirect_url');
+
+		// No need to login again if they are already logged in...
+		if ($auth->isLoggedIn())
+		{
+			unset($_SESSION['redirect_url']);
+			redirect($redirect_url);
+		}
+
+		if ($this->input->post())
+		{
+			$post_data = [
+				'email'    => $this->input->post('email'),
+				'password' => $this->input->post('password')
+			];
+
+			$remember = (bool)$this->input->post('remember');
+
+			if ($auth->login($post_data, $remember))
+			{
+				// Is the user being forced to reset their password?
+				if ($auth->user()['force_pass_reset'] == 1)
+				{
+					redirect( Route::named('change_pass') );
+				}
+
+				unset($_SESSION['redirect_url']);
+				$this->setMessage(lang('auth.did_login'), 'success');
+				redirect($redirect_url);
+			}
+
+			$this->setMessage(lang('auth.invalid_user'), 'danger');
+		}
+
+		$this->themer->setLayout('login');
+		$this->render();
+	}
+
+	//--------------------------------------------------------------------
+
+	public function logout()
+	{
+		$auth = new LocalAuthentication();
+		$this->load->model('user_model');
+		$auth->useModel($this->user_model);
+
+		if ($auth->isLoggedIn())
+		{
+			$auth->logout();
+
+			$this->setMessage(lang('auth.did_logout'), 'success');
+		}
+
+		redirect('/');
+	}
+
+	//--------------------------------------------------------------------
+
+	public function register()
+	{
+		$this->load->helper('form');
+
+		if ($this->input->post())
+		{
+			$auth = new LocalAuthentication();
+			$this->load->model('user_model');
+			$auth->useModel($this->user_model);
+
+			$post_data = [
+				'first_name'   => $this->input->post('first_name'),
+				'last_name'    => $this->input->post('last_name'),
+				'email'        => $this->input->post('email'),
+				'username'     => $this->input->post('username'),
+				'password'     => $this->input->post('password'),
+				'pass_confirm' => $this->input->post('pass_confirm')
+			];
+
+			if ($auth->registerUser($post_data))
+			{
+				$this->setMessage(lang('auth.did_register'), 'success');
+				redirect( Route::named('login') );
+			}
+			else
+			{
+				$this->setMessage($auth->error(), 'danger');
+			}
+		}
+
+		$this->addScript('register.js');
+		$this->themer->setLayout('login');
+		$this->render();
+	}
+
+	//--------------------------------------------------------------------
+
+	public function activate_user()
+	{
+		$this->load->helper('form');
+
+		if ($this->input->post())
+		{
+			$auth = new LocalAuthentication();
+			$this->load->model('user_model');
+			$auth->useModel($this->user_model);
+
+			$post_data = [
+				  'email' => $this->input->post('email'),
+				  'code'  => $this->input->post('code')
+			];
+
+			if ($auth->activateUser($post_data))
+			{
+				$this->setMessage(lang('auth.did_activate'), 'success');
+				redirect( Route::named('login') );
+			}
+			else
+			{
+				$this->setMessage($auth->error(), 'danger');
+			}
+		}
+
+		$data = [
+			'email' => $this->input->get('e'),
+			'code'  => $this->input->get('code')
+		];
+
+		$this->themer->setLayout('login');
+		$this->render($data);
+	}
+
+	//--------------------------------------------------------------------
+
+
+	public function forgot_password()
+	{
+		$this->load->helper('form');
+
+		if ($this->input->post())
+		{
+			$auth = new LocalAuthentication();
+			$this->load->model('user_model');
+			$auth->useModel($this->user_model);
+
+			if ($auth->remindUser($this->input->post('email')))
+			{
+				$this->setMessage(lang('auth.send_success'), 'success');
+				redirect( Route::named('reset_pass') );
+			}
+			else
+			{
+				$this->setMessage($auth->error(), 'danger');
+			}
+		}
+
+		$this->themer->setLayout('login');
+		$this->render();
+	}
+
+	//--------------------------------------------------------------------
+
+	public function reset_password()
+	{
+		$this->load->helper('form');
+
+		if ($this->input->post())
+		{
+			$auth = new LocalAuthentication();
+			$this->load->model('user_model');
+			$auth->useModel($this->user_model);
+
+			$credentials = [
+				'email' => $this->input->post('email'),
+				'code'  => $this->input->post('code')
+			];
+
+			$password     = $this->input->post('password');
+			$pass_confirm = $this->input->post('pass_confirm');
+
+			if ($auth->resetPassword($credentials, $password, $pass_confirm))
+			{
+				$this->setMessage(lang('auth.new_password_success'), 'success');
+				redirect( Route::named('login') );
+			}
+			else
+			{
+				$this->setMessage($auth->error(), 'danger');
+			}
+		}
+
+		$data = [
+			'email' => $this->input->get('e'),
+			'code'  => $this->input->get('code')
+		];
+
+		$this->addScript('register.js');
+		$this->themer->setLayout('login');
+		$this->render($data);
+	}
+
+	//--------------------------------------------------------------------
 
 	/**
 	 * Allows a logged in user to enter their current password
@@ -320,24 +320,24 @@ 
 	//--------------------------------------------------------------------
 
 
-    //--------------------------------------------------------------------
-    // AJAX Methods
-    //--------------------------------------------------------------------
+	//--------------------------------------------------------------------
+	// AJAX Methods
+	//--------------------------------------------------------------------
 
-    /**
-     * Checks the password strength and returns pass/fail.
-     *
-     * @param $str
-     */
-    public function password_check($str)
-    {
-        $this->load->helper('auth/password');
+	/**
+	 * Checks the password strength and returns pass/fail.
+	 *
+	 * @param $str
+	 */
+	public function password_check($str)
+	{
+		$this->load->helper('auth/password');
 
-        $strength = isStrongPassword($str);
+		$strength = isStrongPassword($str);
 
-        $this->renderJSON(['status' => $strength ? 'pass' : 'fail']);
-    }
+		$this->renderJSON(['status' => $strength ? 'pass' : 'fail']);
+	}
 
-    //--------------------------------------------------------------------
+	//--------------------------------------------------------------------
 
 }