class My_View_Helper_Calendar extends Zend_View_Helper_Abstract
{
    protected $date;
    protected $now;
    protected $locale = 'pt_BR';
 
    const INSERT_BEFORE = -1;
    const INSERT_PREPEND = 0;
    const INSERT_APPEND = 1;
    const INSERT_AFTER = 2;
 
    protected $options = array(
        'showPrevMonthLink'  => false,
        'showNextMonthLink'  => false,
        'showOtherMonthDays' => false,
        'dateBaseUrl'        => '#',
        'monthBaseUrl'       => '#',
        'insertsPosition'    => -1
    );
 
    protected $protectedCssClasses = array(
        'selected-date', 'today', 'past-day', 'future-day',
        'other-mohth', 'prev-month', 'next-month'
    );
 
    protected $cssClasses = array();
    protected $inserts = array();
 
    static protected $formats = array(
        'input'    => 'yyyy-MM-dd',
        'weekdays' => Zend_Date::WEEKDAY_NARROW,
        'header'   => 'MMMM yyyy',
        'prevAndNextMonth' => Zend_Date::MONTH_NAME_SHORT
    );
 
    static public function getFormat($name)
    {
        return isset(self::$formats[$name])
                ? self::$formats[$name]
                : null;
    }
 
    /**
     * Set object state from options array
     *
     * @param array $options
     * @return My_View_Helper_Calendar
     */
    public function setOptions(array $options)
    {
        foreach($options as $name => $value)
        {
            // Define o formato que a data será inserida
            if ($name == 'format') {
                self::$formats['input'] = $value;
            }
 
            // Define o idioma
            if ($name == 'locale' && Zend_Locale::isLocale($value)) {
                $this->locale = $value;
            }
 
            // Define as classes de css
            if ($name == 'cssClasses') {
                $this->setCssClasses($value);
            }
 
            // Insere conteúdo nas células de acordo com as datas
            if ($name == 'inserts') {
                $this->insertHtml($value);
            }
 
            // Define a posição em que o conteúdo será inserido
            if ($name == 'insertsPosition') {
                $this->setInsertsPosition($value);
            }
 
            $this->setOption($name, $value);
        }
        return $this;
    }
 
    /**
     * Altera alguma configuração do calendário
     *
     * @param string $name
     * @param mixed $value
     * @return My_View_Helper_Calendar
     */
    public function setOption($name, $value)
    {
        if (isset($this->options[$name])) {
            $this->options[$name] = $value;
        }
 
        return $this;
    }
 
    /**
     * Retorna uma configuração pelo nome
     *
     * @param string $name
     * @return mixed
     */
    public function getOption($name)
    {
        return isset($this->options[$name])
                ? $this->options[$name]
                : null;
    }
 
    /**
     * Define as classes de CSS para datas específicas
     *
     * @param array $cssClasses
     * @return My_View_Helper_Calendar
     */
    public function setCssClasses(array $cssClasses)
    {
        foreach($cssClasses as $cssClass => $dates) {
            $this->addCssClass($cssClass, $dates);
        }
        return $this;
    }
 
    /**
     * Adiciona uma classe de CSS para uma data específica
     *
     * @param string $cssClass
     * @param mixed $dates
     * @return My_View_Helper_Calendar
     */
    public function addCssClass($cssClass, $dates)
    {
        if (!in_array($cssClass, $this->protectedCssClasses)) {
            if (is_string($dates)) {
                $dates = array($dates);
            }
            if (is_array($dates)) {
                foreach($dates as $date) {
                    if (is_string($date) && Zend_Date::isDate(
                        $date, $this->getFormat('input')))
                    {
                        $this->cssClasses[$cssClass][] = $date;
                    }
                }
            }
        }
        return $this;
    }
 
    /**
     * Retorna a lista de classes de css definidas
     *
     * @return array
     */
    public function getCssClasses()
    {
        return $this->cssClasses;
    }
 
    /**
     * Retorna todas as classes de css, tanto as padrão quanto 
     * as definidas
     *
     * @return array
     */
    public function getAllCssClasses()
    {
        return array_merge($this->protectedCssClasses,
                           array_keys($this->getCssClasses()));
    }
 
    /**
     * Adiciona conteúdo html a uma data específica
     *
     * @param string $date
     * @param string $html
     * @return My_View_Helper_Calendar
     */
    public function insertHtml($date, $html=null)
    {
        if (is_array($date)) {
            foreach($date as $d => $h) {
                $this->insertHtml($d, $h);
            }
        } else if (Zend_Date::isDate($date, $this->getFormat('input'))) {
            if (is_string($html)) {
                $this->inserts[$date][] = $h;
            } else if (is_array($html)) {
                foreach($html as $h) {
                    if (is_string($h)) {
                        $this->inserts[$date][] = $h;
                    }
                }
            }
        }
 
        return $this;
    }
 
    /**
     * Retorna o conteúdo HTML adicionado para uma data específica
     *
     * @param string $date
     * @return array
     */
    public function getInserts($date=null)
    {
        if ($date) {
            if (isset($this->inserts[$date])) {
                return $this->inserts[$date];
            }
        } else {
            return $this->inserts;
        }
    }
 
    /**
     * Define a posição do conteúdo inserido nas datas
     * -1 = Antes da tag do link da data
     * 0 = Antes da data, dentro da tag do link
     * 1 = Depois da data, dentro da tag do link
     * 1 = Depois da tag do link da data
     *
     * @param int -1 = Before, 0 = Prepend, 1 = Append, 2 = After
     * @return My_View_Helper_Calendar
     */
    public function setInsertsPosition($position)
    {
        if (in_array($position, 
            array(self::INSERT_APPEND, self::INSERT_PREPEND))) 
        {
            $this->setOption('insertsPosition', $position);
        }
        return $this;
    }
 
 
    /**
     * Returna a posição em que o conteúdo será inserido
     *
     * @return int
     */
    public function getInsertsPosition()
    {
        return $this->getOption('insertsPosition');
    }
 
    /**
     * Define a data selecionada
     *
     * @param string $date
     * @return My_View_Helper_Calendar
     */
    public function setDate($date)
    {
        if ($date instanceof Zend_Date) {
            $this->date = $date;
        } else {
            $this->date = new Zend_Date($date, self::getFormat('input'),
                                        $this->locale);
        }
        return $this;
    }
 
    /**
     * Exibe um calendário HTML
     *
     * @param string $date Data selecionada
     * @param array $options
     * @return string
     */
    public function calendar($date=null, array $options=null)
    {
        if ($options) {
            $this->setOptions($options);
        }
 
        $this->now = Zend_Date::now($this->locale);
 
        if ($date) {
            $this->setDate($date);
        } else {
            $this->date = clone $this->now;
        }
 
        return $this->render();
    }
 
    /**
     * Gera o código HTML do calendário
     *
     * @return string
     */
    public function render()
    {
        // Cria um objeto Zend_Date para a data inicial
        $dateInit = clone $this->date;
        $dateInit->setDay(1); // Altera para o primeiro dia do mês
        $weekday = $dateInit->get(Zend_Date::WEEKDAY_DIGIT);
        $month = $this->date->get(Zend_Date::MONTH);
 
        // Calcula o primeiro dia da tabela a ser exibido
        $firstDay = clone $dateInit->subDay($weekday);
 
        // Cria uma div para o calendário com um id único
        $xhtml = '<div class="calendar" '
                . 'id="calendar_' . $this->date->get('yyyy-MM') . '">'
                . '<div class="calendar-header">';
 
        // Verifica se o calendário está configurado para exibir os 
        // links de navegação para exibir o mês anterior
        if ($this->getOption('showPrevMonthLink'))
        {
            $prevMonth = clone $this->date;
 
            // Cria um objeto para o mês anterior
            $prevMonth->subMonth(1); 
 
            $xhtml .= '<span class="prev-month-link">'
                  . '<a href="'
                  . $this->getOption('monthBaseUrl')
                  . $prevMonth->get('yyyy-MM').'" title="'
                  . $prevMonth->get(self::getFormat('header'))
                  .'">'
                  . $prevMonth->get(self::getFormat('prevAndNextMonth'))
                  . '</a></span>';
        }
 
        // Insere o nome do mês atual de acordo com o formato definido
        $xhtml .= '<span class="current-month">'
                . $this->date->get(self::getFormat('header'))
                . '</span>';
 
        // Verifica se o calendário está configurado para exibir os
        // links de navegação para exibir o mês seguinte
        if ($this->getOption('showNextMonthLink'))
        {
            $nextMonth = clone $this->date;
 
            // Cria um objeto para o mês seguinte
            $nextMonth->addMonth(1); 
 
            $xhtml .= '<span class="next-month-link">'
                  . '<a href="'
                  . $this->getOption('monthBaseUrl')
                  . $nextMonth->get('yyyy-MM').'" title="'
                  . $nextMonth->get(self::getFormat('header'))
                  .'">'
                  . $nextMonth->get(self::getFormat('prevAndNextMonth'))
                  . '</a></span>';
        }
 
        // Cria a tabela do calendário
        $xhtml .= '</div><table cellspacing="0" cellpadding="0" '
                . 'border="0"><thead>';
 
        $tmpDate = clone $firstDay;
 
        // Adiciona sete colunas com os nomes dos dias da semana
        for($i=0; $i<=6; $i++) {
            $cssClasses = array();
 
            // Define as classes de CSS da semana e da coluna
            if ($i == 0) {
                // Classe CSS para a primeira coluna
                $cssClasses[] = 'column-first';
            } else if ($i == 6) {
                // Classe CSS para a última coluna
                $cssClasses[] = 'column-last';
            }
 
            // Adiciona classes CSS diferentes para dias da semana
            // e fim-de-semana
            $cssClasses[] = (in_array(
                $tmpDate->get(Zend_Date::WEEKDAY_DIGIT), array(0, 6)))
                ? 'weekend-day' : 'week-day';
 
            // Adiciona uma classe específica para cada dia da semana
            $cssClasses[] = strtolower(
                $tmpDate->get(Zend_Date::WEEKDAY_NAME, 'en_US'));
 
            // Insere as classes CSS na célula e imprime o dia da semana
            // de acordo com o formato definido
            $cssClassesString = $cssClasses 
                ? ' class="'.implode(' ', $cssClasses).'"' 
                : '';
 
            $xhtml .= '<th' . $cssClassesString . '>'
                    . $tmpDate->get(self::getFormat('weekdays'))
                    . '</th>';
 
            // Avança para o dia seguinte e repete o processo
            $tmpDate->addDay(1);
        }
        $tmpDate = $firstDay;
        $xhtml .= '</thead><tbody>';
 
        // Cria sete linhas na tabela para as semanas
        for($i=0; $i<6; $i++) {
            $xhtml .= '<tr>';
 
            // Cria sete colunas para as datas
            for($j=0; $j<=6; $j++) {
                $day = $tmpDate->get(Zend_Date::DAY);
 
                $cssClasses = array();
 
                // Define as classes de CSS da semana e da coluna
                if ($j == 0) {
                    $cssClasses[] = 'column-first';
                } else if ($j == 6) {
                    $cssClasses[] = 'column-last';
                }
 
                // Adiciona classes CSS diferentes para dias da semana
                // e fim-de-semana
                $cssClasses[] = (in_array(
                    $tmpDate->get(Zend_Date::WEEKDAY_DIGIT),array(0,6)))
                    ? 'weekend-day' : 'week-day';
 
                //Adiciona uma classe específica para cada dia da semana
                $cssClasses[] = strtolower(
                        $tmpDate->get(Zend_Date::WEEKDAY_NAME, 'en_US'));
 
                // Adiciona classes CSS diferentes para hoje, dias 
                //passados e futuros
                switch($tmpDate->compareDate($this->now)) {
                    case -1: $cssClasses[] = 'past-day'; break;
                    case 0: $cssClasses[] = 'today'; break;
                    case 1: $cssClasses[] = 'future-day'; break;
                }
 
                // Adiciona uma classe CSS para a data selecionada
                if ($tmpDate->compareDate($this->date) == 0) {
                    $cssClasses[] = 'selected-date';
                }
 
                // Adiciona classes CSS para dias de outros meses
                if ($tmpDate->get(Zend_Date::MONTH) != $month) {
                    $cssClasses[] = 'other-month';
 
                    if (!$this->getOption('showOtherMonthDays')) {
                        $day = '&nbsp;';
                    }
 
                    // Adiciona classes CSS diferentes para dias de 
                    // meses passado e futuro
                    if ($tmpDate->get(Zend_Date::MONTH) < $month) {
                        $cssClasses[] = 'prev-month';
                    } else if ($tmpDate->get(Zend_Date::MONTH)>$month){
                        $cssClasses[] = 'next-month';
                    }
                }
 
                // Insere classes CSS definidos para datas específicas
                $addCssClasses = $this->getCssClasses();
                if ($addCssClasses) {
                    foreach($addCssClasses as $cssClass => $d) {
                        if ((is_string($d) && $tmpDate->get(
                          $this->getFormat('input')) == $d) ||
                          (is_array($d) && in_array(
                          $tmpDate->get($this->getFormat('input')),$d)))
                        {
                            $cssClasses[] = $cssClass;
                        }
                    }
                }
 
                // Insere conteúdo HTML definido para datas específicas
                $htmlInserts = '';
                $inserts = $this->getInserts(
                    $tmpDate->get($this->getFormat('input')));
                if ($inserts) {
                    foreach($inserts as $insert) {
                        $htmlInserts .= $insert . PHP_EOL;
                    }
                }
 
                // Creia a célula da tabela para a data
                $xhtml .= '<td '
                        . 'id="calendar_day_' 
                        . $tmpDate->get('yyyy-MM-dd') . '" '
                        . 'class="' . implode(' ', $cssClasses) . '">'
                        . ($this->getInsertsPosition() == 
                          self::INSERT_BEFORE ? $htmlInserts : '')
                        . '<a class="day" href="'
                        . $this->getOption('dateBaseUrl')
                        . '/'
                        . $tmpDate->get('yyyy-MM-dd')
                        .'">'
                        . ($this->getInsertsPosition() == 
                          self::INSERT_PREPEND ? $htmlInserts : '')
                        . $day
                        . ($this->getInsertsPosition() == 
                          self::INSERT_APPEND ? $htmlInserts : '')
                        . '</a>'
                        . ($this->getInsertsPosition() == 
                          self::INSERT_AFTER ? $htmlInserts : '')
                        . '</td>';
 
                $tmpDate->addDay(1);
            }
            $xhtml .= '</tr>';
        }
 
        $xhtml .= '</tbody></table></div>';
 
        return $xhtml;
    }
}

<?php echo $this->calendar('2012-02-17', array(
    // Faz com que o link para o mês passado seja exibido
    'showPrevMonthLink'  => true,
    // Faz com que o link para o mês seguinte seja exibido
    'showNextMonthLink'  => true,
    // Faz com que os dias de outros meses sejam exibidos
    'showOtherMonthDays' => true,
    // Define a url base para os links das datas
    'dateBaseUrl'        => 'http://www.jaimeneto.com/data/',
    // Define a url base para os links de navegação dos meses
    'monthBaseUrl'       => 'http://www.jaimeneto.com/data/',
    // Define uma classe css "feriado" para as datas no array
    'cssClasses' => array(
        'feriado' => array(
            '2012-02-01', // Dia do Publicitário
            '2012-02-02', // Dia de Iemanjá
            '2012-02-22', // Carnaval
            '2012-02-16',  // Dia do Repórter
            '2012-03-08'  // Dia da Mulher
        )
    ),
    // Dá um destaque maior inserindo o nome do feriado do carnaval
    'inserts' => array(
        '2012-02-22' => array('<div>Carnaval</div>')
    ),
    // Define que o html deve ser inserido dentro do link, após a data
    'insertsPosition'    => My_View_Helper_Calendar::INSERT_APPEND
)) ?>

body { font-family:arial;font-size:14px }
.calendar { width: 300px;cursor:default; }
.calendar a { text-decoration:none; color:#000; }
.calendar a:hover { text-decoration:underline; }
.calendar .calendar-header { border:1px solid #000;border-bottom:0;
    background-color:#ccc;text-align:center;text-transform:uppercase;
    line-height: 20px; }
.calendar .calendar-header .current-month { font-weight:bold; }
.calendar .calendar-header .prev-month-link { float:left;margin:0 3px; }
.calendar .calendar-header .next-month-link { float:right;margin:0 3px; }
.calendar table { border-collapse:collapse;width:100%; }
.calendar table td, .calendar table th { border:1px solid #000;
    text-align:center; line-height: 20px; }
.calendar table td a { display:block; margin:2px; 
    border: 1px solid transparent; }
.calendar table .weekend-day,.calendar table th {background-color:#eee;}
.calendar table td.other-month a { color:#ccc; }
.calendar table td.today { background-color:orange; }
.calendar table td.selected-date a { background-color:yellow; }
.calendar table td.feriado a { color:blue;border-color:blue; }
.calendar table td.other-month.feriado a {color:#ccc;border-color:#ccc;}

class My_Controller_Plugin_ElapsedTime
    extends Zend_Controller_Plugin_Abstract
{
  /*
   * Constantes que serão usadas para identificar a partir de
   * que parte da execução deseja-se calcular o tempo decorrido.
   * O nome das constantes é baseado no nome das funções que
   * inicializam os valores correspondentes na propriedade
   * $_startTime, logo abaixo
   */
  const EVENT_ROUTE_STARTUP = 1;
  const EVENT_ROUTE_SHUTDOWN = 2;
  const EVENT_DISPATCH_LOOP_STARTUP = 3;
  const EVENT_PRE_DISPATCH = 4;
  const EVENT_POST_DISPATCH = 5;
  const EVENT_DISPATCH_LOOP_SHUTDOWN = 6;
 
  // Guarda o tempo de inicialização de cada parte da execução
  static protected $_startTime = array(
    self::EVENT_ROUTE_STARTUP => null,
    self::EVENT_ROUTE_SHUTDOWN => null,
    self::EVENT_DISPATCH_LOOP_STARTUP => null,
    self::EVENT_PRE_DISPATCH => null,
    self::EVENT_POST_DISPATCH => null,
    self::EVENT_DISPATCH_LOOP_SHUTDOWN => null
  );
 
  // Define o tempo de inicialização antes de as rotas serem
  // inicializadas
  public function routeStartup(
     Zend_Controller_Request_Abstract $request)
  {
    self::$_startTime[self::EVENT_ROUTE_STARTUP] =
        $this->microtime();
  }
 
  // Define o tempo de inicialização depois de as rotas serem
  // inicializadas
  public function routeShutdown(
     Zend_Controller_Request_Abstract $request)
  {
    self::$_startTime[self::EVENT_ROUTE_SHUTDOWN] =
        $this->microtime();
  }
 
  // Define o tempo de inicialização antes de iniciar o loop
  // de dispatch
  public function dispatchLoopStartup(
      Zend_Controller_Request_Abstract $request)
  {
    self::$_startTime[self::EVENT_DISPATCH_LOOP_STARTUP] =
        $this->microtime();
  }
 
  // Define o tempo de inicialização antes do dispatch de
  // uma action
  public function preDispatch(
      Zend_Controller_Request_Abstract $request)
  {
    self::$_startTime[self::EVENT_PRE_DISPATCH] =
        $this->microtime();
  }
 
  // Define o tempo de inicialização depois do dispatch de
  // uma action
  public function postDispatch(
      Zend_Controller_Request_Abstract $request)
  {
    self::$_startTime[self::EVENT_POST_DISPATCH] =
        $this->microtime();
  }
 
  // Define o tempo de inicialização depois de finalizar o
  // loop de dispatch
  public function dispatchLoopShutdown()
  {
    self::$_startTime[self::EVENT_DISPATCH_LOOP_SHUTDOWN] =
        $this->microtime();
  }
 
  /**
   * Retorna o tempo de inicialização de cada evento do plugin,
   * ou de um evento específico, que pode ser passado como
   * parâmetro baseado no valor das contantes desta classe
   *
   * @param int $event
   * @return mixed Float se receber $event, senão, array
   */
  public function getStartTime($event=null)
  {
    if ($event) {
      if (!isset(self::$_startTime[$event])) {
        throw new Zend_Exception('Invalid value for $event: '
           . $event);
      }
      return self::$_startTime[$event];
    }
    return self::$_startTime;
  }
 
  /**
   * Calcula o tempo decorrido de um trecho e código.
   *
   * @param int $event
   * @return float
   */
  public function getElapsedTime(
     $event=self::EVENT_ROUTE_STARTUP)
  {
    $startTime = $this->getStartTime($event);
 
    // Lança uma excessão Caso o evento não tenha sido
    // inicializado ainda
    if (!$startTime) {
      throw new Zend_Exception('Event has not been '
        . 'initialized yet');
    }
 
    // Pega o microtime atual e substrai dele o tempo
    // inicial para calcular o tempo decorrido
    $endTime = $this->microtime();
    $elapsedTime = $endTime - $startTime;
 
    return $elapsedTime;
  }
 
  /**
   * Pega o microtime em formato float, levando em conta as
   * variações sofridas pela função de acordo com a versão do
   * PHP
   */
  private function _microtime()
  {
    if (version_compare(PHP_VERSION, '5.0.0', '>=')) {
      // O parâmetro já converte o restulado da função para
      // float a partir da versão 5.0.0
      return microtime(true);
    } else {
      // Antes da versão 5.0.0, a conversão para float tinha
      // que ser feita manualmente
      list($usec, $sec) = explode(" ", microtime());
      return ((float)$usec + (float)$sec);
    }
  }
}

class My_View_Helper_ElapsedTime
     extends Zend_View_Helper_Abstract
{
  /**
   * Exibe o tempo decorrido de um trecho de código
   * baseado nos valores inicializados no plugin
   * 'My_Controller_Plugin_ElapsedTime'
   *
   * @param int $precision
   * @param string|Zend_Locale $locale
   * @return float
   * @throws Zend_Exception
   */
  public function elapsedTime($precision = null,
      $locale = null, $event =
      My_Controller_Plugin_ElapsedTime::EVENT_ROUTE_STARTUP)
  {
    $pluginClass = 'My_Controller_Plugin_ElapsedTime';
 
    // Verifica se o plugin foi registrado
    if (!Zend_Controller_Front::getInstance()
            ->hasPlugin($pluginClass)) {
      throw new Exception("Plugin '{$_pluginClass}' is not '
          . 'registered");
    }
 
    // Primeiro vamos pegar o plugin lá do front controller,
    // que já foi inicializado
    $elapsedTimePlugin = Zend_Controller_Front::getInstance()
         ->getPlugin($pluginClass);
 
    // Agora vamos pegar o valor calculado do tempo decorrido,
    // passando como parâmetro uma daquelas constantes definidas
    // na classe do plugin, pra dizer a partir de que ponto do
    // código onde calcular o tempo de execução. O padrão é de
    // antes da inicialização das rotas.
    $elapsedTime = $elapsedTimePlugin->getElapsedTime($event);
 
    // Retorna o tempo decorrido formatado, levando em conta o
    // número de decimais a ser exibido e a localização, para
    // apresentar os símbolos de separação de milhares e de
    // decimais corretos
    return Zend_Locale_Format::toFloat($elapsedTime, array(
      'precision' => $precision, 'locale' => $locale));
    }
 
}

resources.frontController.plugins[] = My_Controller_Plugin_ElapsedTime

Essa página foi carregada em <?php echo $this->elapsedTime(2) ?> segundos

<ul><?php
$events = array(
  1 => 'routeStartup',
  2 => 'routeShutdown',
  3 => 'dispatchLoopStartup',
  4 => 'preDispatch',
  5 => 'postDispatch',
//  6 => 'dispatchLoopShutdown'
);
foreach($events as $eventId => $eventName) {
  echo '<li>' . $eventName . ': '
     . $this->elapsedTime(2, 'pt_BR', $eventId)
     . ' segundos</li>';
}
?></ul>

$application->bootstrap()->run();
echo Zend_Controller_Front::getInstance()
    ->getPlugin('Case_Controller_Plugin_ElapsedTime')
    ->getElapsedTime(
            Case_Controller_Plugin_ElapsedTime::EVENT_DISPATCH_LOOP_SHUTDOWN
    );

class My_Filter_Transliterate implements Zend_Filter_Interface 
{
  public function filter($string)
  {
     // Lista de caracteres que devem ser substituídos
     $a = 'ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ$ßàáâãäåæ@çèéêë&'
        . 'ìíîïðñòóôõöøùúûüýýþÿŔŕ°ºª,.;:\|/"^~*%# ()[]{}=!?`‘’' 
        . "'";
 
     // Lista que irá substituir os caracteres acima
     $b = 'aaaaaaaceeeeiiiidnoooooouuuuybssaaaaaaaaceeeee'
        . 'iiiidnoooooouuuuyybyRrooa--------------------------' 
        . '-';
 
     // Efetua a substituição
     $string = strtr($string, $a, $b); 
 
     // Deixa tudo minúsculo
     $string = strtolower($string);
 
     // Evita hífens repetidos
     $string = preg_replace('/--+/', '-', $string); 
     return $string;
  }
}

$filterTransliterate = new My_Filter_Transliterate();
$string = 'Já não era sem tempo de Jaime lançar um post novo '
        . 'nesse blog!!!';
echo $filterTransliterate->filter($string);
// ja-nao-era-sem-tempo-de-jaime-lancar-um-post-novo-nesse-blog-

class My_View_Helper_Transliterate 
    extends Zend_View_Helper_Abstract
{
  public function transliterate($value)
  {
      $filterTransliterate = new My_Filter_Transliterate();
      return = $filterAlias->filter($value);
  }
}

<?php echo transliterate($this->post->title) ?>

/**
* Gera automaticamente um Zend_Db_Table_Select fazendo join nas tabelas
* baseado nas informações do atributo $_referenceMap
*
* @param array $columns Lista de campos a serem retornados
*  do banco de dados (usado para ganho de performance).
*  Se for  null, todos as colunos serão retornados.
* @param array $referenceTables Lista de "rules" das tabelas a serem
*  acrescentadas na query (usado para ganho de performance)
*  Se null, todas as tabelas serão acrescentadas na query.
* return Zend_Db_Table_Select
*/
public function selectWithJoins(array $columns = null,
 array $referenceTables = null)
{
 $select = $this->select();
 
 // Verifica se há restrições nos campos a serem acrescentados
 $retrieveColumns = '*';
 if($columns) {
   $tableCols = $this->info('cols');
   $retrieveColumns = array_intersect($tableCols, $columns);
 }
 $select->from($this->_name, $retrieveColumns);
 
 // Verifica se há tabelas a serem acrescentadas com join na query
 // baseado no $_referenceMap
 if (count($this->_referenceMap) > 0) {
   $select->setIntegrityCheck(false);
   if (!isset($tableCols)) {
     $tableCols = $this->info('cols');
   }
   foreach($this->_referenceMap as $rule=>$rm) {
     // Verifica se há restrições nas tabelas a serem
     // acrescentadas
     if (null === $referenceTables ||
       in_array($rule, $referenceTables))
     {
       $refTableClass = new $rm['refTableClass'];
 
       // Campos das tabelas a serem acrescentadas
       // são renomeadas
       // para "NomeDaRule_NomeDoCampo"
       $refTableColumns = array();
       foreach ($refTableClass->info('cols') as $col) {
         $colAlias = "{$rule}_{$col}";
         // Verifica se há restrições nos campos a
         // serem acrescentados
         if (!$columns || in_array($colAlias, $columns)) {
           $refTableColumns[$colAlias] = $col;
         }
       }
 
       $usedAliases = array($this->_name);
 
       // Se não há campos a serem acrescentados,
       // a tabela não será acrescentada
       if (count($refTableColumns)) {
         $refTableName = $refTableClass->info(self::NAME);
 
         // Se refTable for igual a outra tabela, muda os aliases
         $refTableAlias = $refTableName;
         $i = 2;
         while(in_array($refTableAlias, $usedAliases)) {
           $refTableAlias = $refTableName . '_' . $i++;
         }
         $usedAliases[] = $refTableAlias;
 
         if (is_string($rm['refColumns'])) {
         // Se a chave primária é única
         $joinOnString =
           "{$refTableAlias}.{$rm['refColumns']}"
           . " = {$this->_name}.{$rm['columns']}";
         } else if (is_array($rm['refColumns'])) {
           // Se a chave primária é concatenada
           $joinOnArray = array();
           foreach($rm['refColumns'] as $key=>$rc) {
             $joinOnArray[] = "{$refTableAlias}.{$rc} = "
             . "{$this->_name}.{$rm['columns'][$k]}";
           }
           $joinOnString = implode(' AND ', $joinOnArray);
         }
 
         $select->joinLeft(
           $refTableName,
           $joinOnString,
           $refTableColumns
         );
      }
    }
   }
 }
 
 return $select;
}

/**
* Faz uma busca no banco de dados com joins nas tabelas relacionadas
* baseado no atributo $_referenceMap
*
* @param string|array $where  OPTIONAL An SQL WHERE clause.
* @param string|array $order  OPTIONAL An SQL ORDER BY clause.
* @param array    $columns OPTIONAL Campos a serem retornados
* @param array    $referenceTables OPTIONAL Tabelas a serem acrescentadas
* @param mixed    $fetchMode OPTIONAL Formato do resultado da busca
* @return mixed     Depende do valor de $fetchMode.
*/
public function fetchWithJoins($where = null, $order = null,
array $columns = null, array $referenceTables = null,
$fetchMode = Zend_Db::FETCH_OBJ)
{
$select = $this->selectWithJoins($columns, $referenceTables);
 
if ($where !== null) {
  $this->_where($select, $where);
}
 
if ($order) {
  $select->order($order);
}
 
return $this->getAdapter()->fetchAll($select, null, $fetchMode);
}
 
/**
* Faz uma busca usando a chave primária no banco de dados com joins
* nas tabelas relacionadas baseado no atributo $_referenceMap
*
* @param string|array $pkey  Valor da chave primária
* @param array    $columns OPTIONAL Campos a serem retornados
* @param array    $referenceTables OPTIONAL Tabelas a serem acrescentadas
* @param mixed    $fetchMode OPTIONAL Formato do resultado da busca
* @return mixed     Depende do valor de $fetchMode.
*/
public function findWithJoins($pkey, array $columns = null,
array $referenceTables = null, $fetchMode = null)
{
// Ver posts anteriores para entender este método 
$where = $this->_generateRestrictionsFromPrimaryKeys($pkey);
 
$result = $this->fetchWithJoins($where, null, $columns,
        $referenceTables, $fetchMode);
return count($result) == 1 ? current($result) : $result;
}

class Cidades extends My_Db_Table_Abstract
{
 protected $_name    = 'cidades';
 protected $_primary = 'id_cidade';
 
 protected $_dependentTables = array('Usuarios');
}
 
class Usuarios extends My_Db_Table_Abstract
{
 protected $_name    = 'usuarios';
 protected $_primary = 'id_usuario';
 
 protected $_referenceMap = array(
   'Cidade' => array(
     'columns'       => 'id_cidade',
     'refTableClass' => 'Cidades',
     'refColumns'    => 'id_cidade'
   ),
 )
}

$idUsuario = 1;
$tbUsuarios = new Usuarios();
$usuario = $tbUsuarios->findWithJoins($idUsuario);

$usuarios = StdClass(
  'id_usuario'       => 1,
  'nome'             => 'Fulano de Tal',
  'id_cidade'        => 40,
  'Cidade_id_cidade' => 40,
  'Cidade_nome'      => 'João Pessoa',
  'Cidade_estado'    => 'PB'
);

$where = array('estado = ?' => 'PB');
$order = array('cidades.nome ASC');
$usuarios = $tbUsuarios->fetchWithJoins($where, $order, 
                         array('nome', 'Cidade_nome'));

$order = array('usuarios.nome ASC');
$usuarios = $tbUsuarios->fetchWithJoins(null, $order, null, 
                         array('Cidade'));

class My_Db_Table_Abstract extends Zend_Db_Table_Abstract 
  <strong>implements Countable</strong>
{
  /* Aqui ficam os métodos citados nos posts anteriores */
 
  public function count($where = null)
  {
     $select = $this->select();
 
     if ($where !== null) {
         $this->_where($select, $where);
     }
 
     $select->from($this->_name, array('count' => 'COUNT(*)'));
 
     $count = $this->getAdapter()->fetchRow($select);
     return intval($count['count']);
  }
}

$tbUsuarios = new Usuarios();
$qtty = $tbUsuarios->count();

$qtty = $tbUsuarios->count("email LIKE '%@gmail.com'");

$id = $this->_request->getPost('id');
 
$tbUsuarios = new Usuarios();
// Imaginemos que esses dados vieram de um formulário
$dados = array(
  'nome' => 'Fulaninho de Tal',
  'email' => 'fulaninho@email.com'
);
$where = $tbUsuarios->getAdapter()->quoteInto('id = ?', $id);
// Vamos atualizar o usuário
$tbUsuarios->update($dados, $where);
 
// E agora excluímos
$tbUsuarios->delete($where);

class My_Db_Table_Abstract extends Zend_Db_Table_Abstract
{
  protected function _filterData(array $data)
  {
    /* Permanece a mesma coisa */
  }
 
  /**
   * Gera restricoes SQL de acordo com a(s) chave(s) primária(s)
   * @param  String|array $pkey chave(s) primária(s)
   *                            [nome_do_campo => valor]
   * @return String|array SQL where
   **/
  protected function _generateRestrictionsFromPrimaryKeys($pkey)
  {
    $where = array();
    if (is_array($this->_primary)) {
      foreach($this->_primary as $key) {
        if (is_array($pkey)) {
          $where[] = $this->getAdapter()
            ->quoteInto($this->_name.'.'.$key . ' = ?',
                        $pkey[$key]);
        } else {
          $where = $this->getAdapter()
            ->quoteInto($this->_name.'.'.$key . ' = ?',
                        $pkey);
        }
      }
    } else {
      $where = $this->getAdapter()
        ->quoteInto($this->_name.'.'.$this->_primary . ' = ?',
                    $pkey);
    }
    return $where;
  }
 
  public function insert(array $data)
  {
    /* Permanece a mesma coisa */
  }
 
  public function update(array $data, $where)
  {
    $data = $this->_filterData($data);
    return parent::update($data, $where);
  }
 
  /**
   * Update de um registro único, baseado na chave primária
   * @param array $data Dados a serem atualizados
   * @param string|array $pkey Valor da chave primária
   **/
   public function updateRow(array $data, $pkey)
   {
    $where = $this->_generateRestrictionsFromPrimaryKeys($pkey);
    return $this->update($data, $where);
  }
 
  /**
   * Delete de um registro único, baseado na chave primária
   * @param string|array $pkey Valor da chave primária
   **/
  public function deleteRow($pkey)
  {
    $where = $this->_generateRestrictionsFromPrimaryKeys($pkey);
    return $this->delete($where);
  }
}

// para atualizar um usuário
$tbUsuarios->updateRow($dados, $id);
 
// para excluí-lo
$tbUsuarios->deleteRow($id);