KISS - Keep it simple, stupid!

Apesar das melhorias introduzidas no HTMLHelper do CakePHP 1.2, sempre achei ridículo ele gerar marcação apenas em XHTML. Sempre preferi HTML, e me via engessado pelo CakePHP nesse aspecto.

Acredito que muitos passam por essa dificuldade quando estão trabalhando com o HTMLHelper e FormHelper do CakePHP. Uma das principais consequências disso, é que o código gerado na maioria das vezes não é válido, pois mistura tags HTML e XHTML.

Mas sempre imaginei que deveria haver um meio de contornar isso. Certa vez verifiquei que existia um método chamado docType no HTMLHelper, e que era possível definir HTML 4.01 com ele. Mas minha alegria logo acabou quando percebi que ele não alterava o comportamento do Helper para gerar tags HTML.

Finalmente, hoje acabei me deparando com uma alternativa. Cansado de mensagens de código inválido fiz uma leitura mais cuidadosa do manual do CakePHP e encontrei a página que diz como gerar tags HTML 4.01. A solução não é muito elegante, mas é uma alternativa presente no próprio framework.
Espero que a solução sirva para vocês também!

Update 1:Para quem estiver com preguiça de fazer o arquivo do zero, fiz um repositório no Github com o arquivo e algumas tags. Conforme for sentindo necessidade vou aumentar o conteúdo dele. Quem quiser colaborar, está convidado!

Update 2: Apliquei as sugestões do Juan Basso, agora um Helper está disponível para manter as tags HTML 4.01. Vejam a discussão abaixo. O link do Github contínua o mesmo. Mantive o arquivo anterior para quem preferir o método da documentação do Cake.

Hoje aconteceu mais uma apresentação sobre temas relacionados a programação aqui para a equipe da souÁgil. Falamos sobre um tema que gera bastante polêmica entre uma equipe de programadores, por se tratar muitas vezes de uma preferência pessoal. Mas que tema é esse?
Padrões de escrita de código em PHP.
Especialmente no caso do PHP, a polêmica é ainda maior, uma vez que a linguagem não possui nenhum padrão estabelecido oficialmente.

Aqui vai a apresentação:

Acredito que em qualquer projeto essa prática é importante, e o objetivo dessa apresentação é mostrar alternativas existentes em PHP. Quem gostar de algum deles pode adotá-lo ou criar o seu, mas lembre-se que toda a equipe deve ter uma maneira fácil de conhecê-lo.
É isso, espero que ajude a quem precisar.

Vocês já devem ter percebido através dos posts do blog que damos grande importância para os testes de software. As razões para isso são diversas, mas certamente a principal está relacionada a confiabilidade.

Nossa linguagem de programação preferida, o PHP, sempre sofreu diversos ataques com relação a esse aspecto, normalmente comparado a outras linguagens de programação como Java, Python, Ruby e até C++. Não que ele seja uma linguagem imaculada, mas não é limitado ou ruim como muitos dizem por ai.
Se vocês acompanham o desenvolvimento da linguagem, devem saber que a versão 5.3 está quase saindo do forno, e vem com várias promessas bastante promissoras.

Uma delas, que acredito que seja uma das melhores iniciativas desse release, é o PHP Quality Assurance. O PHP QA é uma iniciativa de um grupo de desenvolvedores que deseja ajudar o grupo principal de desenvolvimento do PHP, melhorando a qualidade da linguagem. Entre as estratégias e objetivos, temos diversas iniciativas associadas a testes automatizados, análise e reporting de bugs.

Só que uma das partes mais interessantes ainda não foi mencionada. Se você se preocupa com a qualidade da sua linguagem de programação preferida e gostaria de ajudar ela a melhorar, agora você tem mais uma maneira de fazer isso! Você quer saber como?
Agora você pode escrever testes para o PHP!
E não é só isso! Agora você também pode acompanhar o andamento dos testes existentes e o code coverage para cada versão. Outro modo de ajudar é testanto a compilação dos Release Candidates atuais.

Não conheço nenhuma iniciativa semelhante por parte de outras linguagens de programação, alguém sabe de alguma?
Essa talvez seja uma das grandes vantagens do PHP com relação a outras linguagens de programação, o tamanho da comunidade e a abertura dada para que ela possa contribuir.
Agora ninguém tem desculpa pra não ajudar o PHP a se tornar uma linguagem de programação cada vez melhor. E quando vocês ouvirem que ele é uma linguagem não confiável, já sabem aonde recorrer para provarem o contrário.
Good coding!

Na última sexta-feira, 17/04, participei como palestrante de uma das etapas do processo seletivo da Empresa Júnior de Computação (Cop-Jr) da Universidade Estadual de Londrina (UEL).
Para quem quiser ir direto para os downloads, use a âncora.

Durante três dias foram abordados os assuntos:

• Metodologia Ágil
• HTML/CSS
• PHP e CakePHP

Fui o palestrante do último dia, falando sobre PHP e CakePHP. Visto que o grupo de inscritos era em sua maioria do primeiro ano do curso de Ciência da Computação, o conteúdo dos slides é bem introdutório. Procurei focar em conceitos e boas práticas, já que eles ainda vão aprender a programar.
Como exemplo, desenvolvi o blog do tutorial do CakePHP, onde é possível mostrar vários conceitos para quem está começando. Logo depois disso o Lucas acabou com minha apresentação, mostrando o Scaffolding….
Assim não vale, os caras tem que sofrer pelo menos um pouco!

Espero que eles tenham aproveitado e aprendido, e peço para quem tiver sugestões enviar nos comentários.
E sejam bem vindos, novos padeiros!

A apresentação está no formato odp, pra quem não tiver o OpenOffice, segue o link para download.
Apresentação processo seletivo da Cop-Jr
Blog desenvolvido em PHP puro e CakePHP

Ao acompanhar a lista de discussão CakePHP Tuga percebi que existe uma dúvida que sempre dá as caras por lá: preencher as opções de um select box baseado na escolha de um select box preenchido anteriormente. O maior exemplo disso é o famoso “select cidade estado” ou “combo box cidade estado”.

Essa dúvida retornou novamente, mas através de um e-mail enviado para o pessoal da empresa por um amigo de faculdade com a mesma dúvida. No e-mail ele ainda referenciava duas fontes [1] [2] em que havia tentado, mas não obtia sucesso. Talvez a dificuldade seja o idioma, então decidi fazer um exemplo e disponibilizar para a comunidade. Este exemplo utiliza a famosa combinação de seleção do estado e depois da cidade, sendo que o select box de cidades é preenchido a partir da escolha do estado.

Criei mais coisas que o necessário pensando que esses arquivos poderão ser utilizados para outros projetos, um exemplo disso é o modelo de cidades, que não possui basicamente nada, mas pode ser aumentado para inserção de cidades em um determinado estado.

Atualmente tudo deve ser feito diretamente no banco de dados. Vamos iniciar com sua criação:

DROP TABLE IF EXISTS `cidades`;
CREATE TABLE IF NOT EXISTS `cidades` (
  `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT,
  `estado_id` int(10) UNSIGNED NOT NULL,
  `cidade` varchar(50) collate utf8_unicode_ci NOT NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8 ;
 
DROP TABLE IF EXISTS `estados`;
CREATE TABLE IF NOT EXISTS `estados` (
  `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT,
  `sigla` char(2) character SET utf8 NOT NULL,
  `estado` varchar(30) character SET utf8 NOT NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8 ;

Logo depois criamos os modelos:

class Estado extends AppModel
{
    var $name = 'Estado';
    var $hasMany = array(
        'Cidade' => array(
            'dependent' => true
        )
    );
}
class Cidade extends AppModel
{
    var $name = 'Cidade';
    var $belongsTo = 'Estado';
}

Até esse ponto nenhuma novidade, agora vamos aos controllers. O controller de cidades está quase vazio, contém somente sua declaração.
Vou colocar apenas o de estados.

class EstadosController extends AppController
{
    var $name = 'Estados';
    var $helpers = array('Html', 'Form', 'Javascript', 'Ajax');
    var $components =  array('RequestHandler');
    function lista_cidades()
    {
        $estados = $this->Estado->find('list',
            array(
                'fields' => array('Estado.id', 'Estado.estado'),
            )
        );
        $this->set('estados', $estados);
    }
    function cidades_estado()
    {
        $cidades = $this->Estado->Cidade->find('list',
            array(
                'conditions' => array('Cidade.estado_id' => $this->data['Estado']['estado']),
                'fields' => array('Cidade.id', 'Cidade.cidade'),
                'order' => array('Cidade.cidade ASC')
           )
        );
        $this->set('cidades', $cidades);
    }
}

Aqui começa a ficar interessante, observem que foi necessário carregar os helpers Ajax e Javascript além do component RequestHandler. Esses são os responsáveis pela mágica. O primeiro método é a página que possui as combo box de estado e cidade. O segundo, é responsável por trazer as cidades referentes a um estado.

Vejam agora a primeira view:

<?php
    echo $javascript->link('prototype', false);
    echo $javascript->link('http://cidades-estados-js.googlecode.com/files/cidades-estados-1.0.js', false);
    echo $javascript->link('cidade_estado', false);
?>
    <fieldset>
        <legend>CakePHP Way</legend>
<?php
    echo $form->input('Estado.estado', array('options' => $estados));
    echo $form->input('Estado.cidades', array('options' => array()));
    echo $ajax->observeField('EstadoEstado',
        array(
            'update' => 'EstadoCidades',
            'url' => array('controller' => 'estados', 'action' => 'cidades_estado')
        )
    );
?>
    </fieldset>
    <fieldset>
        <legend>Cidades-Estado</legend>
<?php
    echo $form->input('estado', array('type' => 'select'));
    echo $form->input('cidade', array('type' => 'select'));
?>
    </fieldset>

Nesta view chamados o prototype, necessário para que o cake consiga realizar as requisições ajax, preencher o segundo select box, etc. Lembrando que ele deverá estar na pasta webroot/js da sua aplicação. No primeiro fieldset declaramos dois campos select, sendo um já preenchido com os estados encontrados no banco e trazidos pelo controller, o segundo deverá ter seus valores preenchidos com as cidades de um estado selecionado. O método observeField do helper ajax é utilizado no select com id EstadoEstado, que chama a action cidades_estado do controller estado. Essa action é responsável por trazer a lista de cidades do estado selecionado. Ao finalizar a requisição, o select box com id EstadosCidade deverá ser atualizado com o resultado retornado pela action.
Esse resultado deverá ser um conjunto de options com as cidades, gerado na view abaixo:

if(!empty($cidades))
{
    foreach ($cidades as $id => $cidade)
    {
        echo '<option value="'.$id.'">'.$cidade.'</option>';
    }
}

Pronto, já temos um select de estados > cidade condicional em ajax funcionando. Lembrando que esse exemplo pode ser abstraído para qualquer outra necessidade semelhante.

Aproveitando que esse tipo de necessidade é bastate comum, aproveitei para mostrar um pequeno script que já faz todo o trabalho para você.
Trata-se de um projeto hospedado no googlecode, que faz todo o trabalho sujo para você chamado cidades-estado-js. A única coisa necessária é adicionar o fonte e dizer onde ele deverá funcionar.
Neste exemplo ele é o segundo script adicionado. O terceiro script é quem diz onde deverão ser colocadas as cidades e estados. Veja seu fonte, que utiliza prototype.

$(document).observe('dom:loaded', function(){
    new dgCidadesEstados({
        estado: $('estado'),
        cidade: $('cidade')
    });
});

Pronto, com poucas linhas de código já se tem toda a funcionalidade. Agora basta escolher a versão em CakePHP ou a cidades-estados-js.
Para quem deseja muita agilidade, utilize a cidades-estado-js. Para quem quer velocidade e flexibilidade total, mãos a obra com CakePHP.

Acredito que esse post do pinceladas web também possa interessar a quem está lendo até esse ponto. Ele contém um arquivo sql com todas as cidades e estados do Brasil.

[1] – http://www.devmoz.com/blog/2007/04/04/cakephp-update-a-select-box-using-ajax/
[2] – http://www.jamesfairhurst.co.uk/posts/view/using_ajax_to_populate_a_select_box_in_cakephp/

Comecei a programar para web usando PHP, quando o a versão 4 reinava sem nenhuma interferência do versão 5. Na época, ainda não trabalhava com Orientação a Objetos, mas tinha o interesse em aprender. Foi então que decidi aprender logo o PHP 5, pois li que seu suporte a O.O. era muito melhor. Hoje lamento o fato do PHP 4 ser descontinuado somente agora, se fosse naquele tempo não notaria a diferença.

Em conjunto com o PHP tive que aprender uma variedade de coisas para realmente poder desenvolver. HTML, CSS, UML, JavaScript, SQL, arquitetura Cliente-Servidor, HTTP, entre outros. Pois é, eu imaginava que somente com o PHP faria milagres, afinal era muito mais fácil que C, a linguagem que melhor conhecia. Agora vocês perguntam: “C? Mas C para web? Por que não iniciou com outra?” Calma, inicei na programação com desktop, programas de faculdade. Com isso tive uma boa base, mas o que eu realmente queria era Web!

Após algum tempo já conseguia desenvolver aplicações um pouco mais completas. Já possuia conhecimento para desenvolver aplicações orientadas a objeto, utilizando banco de dados, o que pra mim era impressionante. Mas com os projetos sendo finalizados e iniciados, percebi que sempre havia a necessidade de implementar alguns módulos em todos os projetos. Para minimizar o meu trabalho resgatei alguns códigos já desenvolvidos, realizei um refactoring (é impressionante como um código pode melhorar depois de alguns meses após o seu término) e montei algumas classes com esses códigos que sempre utilizava em projetos. Agora sim, a maioria dos requisitos mais comuns podia ser implementada só com algumas chamadas de métodos que eu conhecia, afinal, havia desenvolvido.

Desenvolver suas próprias soluções e poder utilizá-las em diversos sistemas é algo bastante gratificante, pois mostra que o que foi desenvolvido está correto, certo? Nem sempre, a única pessoa que garantia que meu código estava correto era eu mesmo. Não havia mais ninguém que poderia falar bem de meu código. Testes? Na época eu testava, sim. Mas não seguia nenhuma metodologia.

Rodou e deu uma resposta certa? Beleza! Funciona!.

Mesmo nunca tendo grandes problemas com as minhas classes, ainda era necessária uma camada a mais de profissionalismo.
Em algumas “conversas de desenvolvedor” acabei conhecendo através de meus companheiros o framework CakePHP. Fiquei muito animado com as informações que tive quando conheci, tudo parecia fácil e rápido, uma ótima primeira impressão! Logo entrei no site, fiz o download, li algumas especificações, achei coisas mais interessantes do que já havia ouvido falar. Era o momento de começar a desenvolver. Apesar da experiência com PHP e outros conhecimentos relacionados a web, acabei esbarrando no conceito de MVC. Já desenvolvia em camadas há algum tempo, mas da minha maneira; eu fazia meu MVC. Tive um pouco de dificuldade para aprender, era até engraçado: “De onde surgiu essa variável? Essa classe, onde foi declarada?”. Via o pessoal programando com o CakePHP e achava tudo muito incrível. Quando chegava minha vez, era frustante.

Mas, da mesma maneira que acontece com qualquer linguagem, existe uma curva de aprendizado. Como já programava em PHP imaginei que seria muito fácil sair desenvolvendo bem em CakePHP. Depois de compreender como o Framework é estruturado e o funcionamento do MVC, foi tudo voltando a normalidade. Bastam algumas consultas no manual ou na API para resolver as dúvidas. Agora sim, encontrei uma solução confiável! E dessa vez, não sou apenas eu que digo isso, mas toda uma comunidade. Além disso, confirmo a minha impressão inicial, realmente é muito fácil e rápido. Além disso, a estrutura do MVC proporciona uma separação entre dados e lógica que ajuda muito no desenvolvimento, ficando extremamente mais simples de realizar manutenção em código, visto que o problema é mais fácilmente localizado.

Agora, vamos a um pequeno exercício de imaginação que resume tudo isso. Imagine que você precisa fazer um bolo rapidamente. Agora vamos imaginar quatro situações.

Na primeira você só dispõe de uma fogueira. Não há tigelas, colheres, nada, somente a fogueira. Você tem liberdade para utilizar qualquer recurso e transformá-lo em ferramenta. Certamente, nesse contexto, você se tornará alguém muito flexível, pois ganhará capacidade de fazer o bolo com muitos meios diferentes, entretanto, até conseguir montar as ferramentas necessárias para confecção do bolo, muito tempo teria passado e até mesmo a fogueira já poderia ter se apagado. Agora faça uma analogia com a minha experiência em C. Aprendi a programar e a realizar tarefas de diversas maneiras, entretanto, quando fosse necessária agilidade no desenvolvimento, provavelmente perderia muito tempo desenvolvendo uma solução, que ao fim poderia dar errado.

Agora pense que você possui um fogão a lenha, algumas ferramentas rudimentares e uma forma para o bolo. Ainda não será muito ágil seu desenvolvimento, pois somente para acender o fogo você terá que cortar lenha e colocar no fogão. Além disso, ainda será necessário preparar os ingredientes do bolo com ferramentas que nem sempre são adequadas ou que ainda podem melhorar muito. Apesar de ser um pouco mais rápido que a situação anterior, ainda não é uma maneira muito profissional de cozinhar, e está em total desuso nos padrões atuais. Agora ligue esses fatos ao PHP 4. Apesar de ser possível fazer muitas coisas interessantes, é necessário pensar em diversas características que são obsoletas ou podem melhorar.

Agora pense que você possui um fogão industrial! Puxa, melhorou bastante! Além do fogão você tem muitas ferramentas, desde pequenas colheres até batedeiras. Fazer o bolo nesse ponto será muito mais fácil, mesmo que você não saiba como. Procure uma receita e apenas siga os passos. É bem provável que o resultado obtido nesse ponto seja bem interessante, e um pouco menos demorado, dependendo da complexidade da receita. Ao terminar você vê o seu bolo e se orgulha do resultado, ele parece extremamente saboroso. Mas, certamente nem todos vão gostar dele. Algo semelhante pode acontecer com minhas classes em PHP 5. Apesar de ser muito interessante pra mim utilizá-las, não garanto que elas serão efetivas em todos os sistemas, e que poderão ser utilizadas em qualquer sistema sem modificações.

Finalmente, imagine que você possui um microoondas e uma daquelas caixinhas de bolo! Agora vocês pensam:

Mas o bolo de microondas é muito inferior ao bolo feito no fogão ingrediente a ingrediente!

Concordo plenamente com vocês. Minha mãe é confeiteira, sei como demora e dá trabalho, mas também sei como fica gostoso um bolo feito passo a passo! Mas estamos analisando agilidade. O bolo de microondas fica pronto em poucos passos e pouco tempo. Além disso, a probabilidade de dar errado é mínima, basta seguir a receita do verso e não ultrapassar o tempo necessário para que ele fique pronto. Isso é o que possível com o CakePHP. Uma solução robusta, rápida e testada. Apesar de desenvolver suas próprias soluções ser extremamente mais saboroso e gratificante, projetos não estão somente ligados a parte de programação. São necessárias algumas garantias que o CakePHP ajuda a maximizar.

Aos que não conhecem o CakePHP, fica meu incentivo para que garantam sua fatia desse bolo delicioso! Bom apetite!

photo credit: Aaron_M