No mundo PHP, o PHPUnit é a principal ferramenta para testes unitários.
A instalação é bem simples, e utilizando o NetBeans como IDE fica mais fácil ainda.
Abaixo segue um passo a passo:

Para instalar o PHPUnit é preciso ter o Pear, caso não tenha
# sudo apt-get install php-pear

Após instalar o Pear, é necessário registrar o canal no ambiente
# sudo pear channel-discover pear.phpunit.de

E enfim, instalar o PHPUnit
# sudo pear install phpunit/PHPUnit

Pronto, se tudo deu certo até aqui, o PHPUnit foi instalado com sucesso!
Agora vamos configurar para usar no NetBeans.

OBS: Estou usando a última versão do NetBeans, que hoje é 6.9.1

1 – Tools > Options e selecione a aba PHP

Tools > Options

2 – No campo PHPUnit source informe o caminho do PHPUnit, no meu caso /usr/bin/phpunit

Pronto.
Agora para testar crie um diretório em sua aplicação com o nome que desejar. Esse diretório será o repositório de seus testes.
Crie uma classe, e clique com o botão direito em cima.
Tools > Create PHPUnit tests
Selecione o diretório criado como repositório dos testes.
A partir de agora todos seus testes serão armazenados neste diretório.
Para criar novos testes, basta repetir o procedimento.

Claro que nem tudo é tão simples, é preciso entender como funciona um teste unitário, e entender a ferramenta.
Para isso > http://www.phpunit.de/manual/3.4/en/index.html

Boa sorte, e espero ter ajudado.

* Intellisense: Basicamente é a referência da linguagem. O famoso auto-completar, que muitos não vivem sem, ou melhor, não trabalham sem. [#FlameWar]

Mas voltando ao PHP que é o que nos interessa.
Com PHP é possível fazer a mesma coisa que fazemos com outras linguagens.
O NetBeans é uma excelente IDE, e possui uma série de recursos que ajudam no desenvolvimento.
O auto-completar funciona muito bem, e podemos facilmente configura-lo para debugar nossas aplicações, e é isso que vamos ver agora.

Requisitos:
- Obviamente o Apache com PHP. Caso não tenha:
# sudo apt-get install apache2 (Apache)
# sudo apt-get install php5 (PHP 5)
# sudo apt-get install libapache2-mod-php5 (Lib Apache PHP)
# sudo /etc/init.d/apache2 restart (Reinicia Apache)

- Xdebug:
# sudo apt-get install php5-dev (Pacote de libs para compilar as extensões)
# sudo apt-get install php-pear (PEAR http://pear.php.net)
# sudo pecl install xdebug (Xdebug http://www.xdebug.org)

Adicione ao php.ini as configurações para o Xdebug:
# zend_extension=”/usr/lib/php5/20090626+lfs/xdebug.so”
# xdebug.remote_port = 9100 (porta que o xdebug irá responder)
# xdebug.remote_handler=”dbgp” (default)
# xdebug.remote_host=”localhost” (host que o xdebug está rodando)
# xdebug.remote_enable = On (Debug remoto)

Feito isso, reinicie o Apache e está tudo pronto.
Agora com NetBeans abra o seu proejto, crie break-points e faça o Debug de sua aplicação.

PHP Debug NetBeans Xdebug

Espero que o post tenha ajudado a desmistificar mais uma inverdade sobre o PHP.
Lembrando sempre que o bom programador programa em qualquer linguagem, utiliza todas as ferramentas necessárias para resolver o seu problema e não se detêm a uma simples tecnologia.
Abram a mente.

Abraço.

include('Zend/Loader.php');
Zend_Loader::registerAutoload();

Para solucionar o problema basta usar o Zend_Loader_Autoloader.
Em minha implementação apenas o trecho abaixo resolveu o problema:

include('Zend/Loader/Autoloader.php');
$autoloader = Zend_Loader_Autoloader::getInstance();

function _(i,m,callback){
     setTimeout(function(){
       return i>1?_(--i,m,callback):false;
    },m);
    callback(i);
}

Simples, não?
Mais abaixo vou explicar o que acontece.
Com essa função é possível fazer implementações deste tipo:

/*
   Irá executar 5 vezes no intervalo de 500 milisegundos a função anônima abaixo.
*/
_(5,500,function(){
        // XHR buscando um JSON
	$.getJSON('sample.json',function(jsonObject){
		console.log(jsonObject);
	});
});

/*
   Irá executar 44 vezes no intervalo de 1 segundo a função anônima abaixo.
*/
_(44,1000,function(){
       console.log('X');
});

Bom, esta função resolveu um problema específico que enfrentei, e resolvi posta-la para quem possa precisar um dia.
Mas o interessante é sua implementação em poucas linhas e sua recursividade.

Explicação:
Notem que a função recebe 3 parâmetros (i,m,callback) onde:
i = Quantidade de vezes que a função deve ser executada
m = Intervalo em milisegundos
callback = Função a ser executada

A primeira ação da função é executar o setTimeout() passando a função e os milisegundos.
Logo uma operação ternária para verificar se a quantidade é maior que 1. Porque isso?
Porque para economizar variáveis auxiliares e outras possíveis complicações, o que fiz foi decrementar a quantidade de vezes, ou seja, se a função deve ser executada 5 vezes, começo em 5 até chegar a 1.
Se ainda é maior então chamamos a mesma função recursivamente, e claro, decrementando a quantidade de vezes.
OBS: O decremento à esquerda (–i) faz com que a variável i seja decrementada antes de ser passada para a função.
A cada chamada, a função passada é executada e ainda devolve o índice atual para possível manipulação.

Enfim, esta foi minha solução, caso consigam desenvolver outra, ou já tenham feito algo parecido, postem ai!

Mas hoje venho falar de uma possibilidade muito interessante que mais uma vez devo a  dica ao Ricardo Tomasi, que é a customização de expressões.
Uma rápida pesquisa no Google e voces encontraram varios posts espalhados pelo mundo falando a respeito.
Customizar uma expressão consiste em incorporar ao jQuery um método que ele não possui nativamente.

Mas porque diabos fazer isso?
Acreditem, pode ser bem útil.

No curso de jQuery que estou ministrando na Target Trust, ontem bolei um exercício simples para os alunos:

“Mude a cor de fundo de todas as TD’s com indice ímpar da tabela com id tabela2″

Sacaram a ideia?
Simples. O que eu queria, é que eles fizessem da maneira deles, usando um loop, verificando o mod do indice e assim aplicar o css no elemento, para então depois apresentar o seletor odd que faz exatamente isso, só que em uma linha.

$(“table td:odd”).css(“background-color”, “#bbbbff”);

Tudo tranquilo, mas um dos alunos muito antenado achou o seletor e resolveu o problema facilmente!
Então mudei a estratégia, e pedi para ele implementar um algoritmo que apenas aplicasse o estilo nas TD’s com indice que fosse número primo.
Novamente o aluno conseguiu.
Foi ai que lembrei da possibilidade de customização das expressões!
Fiz a proposta para o aluno: Se tu conseguir criar uma expressão customizada que retorne elementos baseando-se nos numeros primos terá um post no meu blog!
Então ai esta. Abaixo segue o código implementado pelo aluno Andre Pinto da turma de jQuery Maio/2010:

jQuery.extend( jQuery.expr[':'], {
	prime: function(a, index){
		function isPrime(num){
			var numHalf = num / 2, counter, divCheck;
				if (num === 2){
					return true;
				}
				if (num < 2 || numHalf === Math.floor(numHalf) ||
                                   num !== Math.floor(num)){
					return false;
				}else{
					for (counter = 3; counter <= Math.sqrt(num);
                                              counter += 2){
						divCheck = num / counter;
						if (divCheck === Math.floor(divCheck)) {
							return false;
						}
					}
				return true;
			       }
		}
           return isPrime(index);
     }
});

Para usar a expressão:

$('#tabela2 td:prime').css( { 'background-color' : 'red' } );

Parabéns ao André pela implementação.

Se você tem R$20,00 e me dá R$20,00, no final, eu tenho R$20,00 e você não tem mais nada.

Se você sabe um teorema e me ensina, ao final eu tenho o teorema, mas você o conserva também.

Então, o conhecimento não obedece às leis da troca mercantil, ele tem mesmo a virtude

de fazer exatamente o oposto…Em vez de um jogo de resultado nulo, ele suscita a multiplicação

do seu valor.

Michel Serres

A instalação do node não é nada complexa, porém exige alguns cuidados.
Estou no Ubuntu, e seguindo as instruções do site, de primeira não funcionou.
Agradeço aqui ao Ricardo Tomasi pelas dicas sobre a instalação do node.  ;)

São poucos passos, abra o terminal e  execute estes simples comandos:

./configure
make
make install

Se tudo funcionou, ou seja, não acusou nenhuma falha [FAIL] é porque o nodeJS foi instalado corretamente.
No meu caso a falha ocorreu porque eu não tinha nenhum compilador GCC e G++.
Bastou abrir o Synaptic, selecionar a categoria Development, procurar por G++ e pronto.
G++ instalado agora o próximo passo é executar:

sudo make test

Feito. Agora vamos criar um clássico Hello World com o node.
Parto do princípio que tudo deu certo até aqui, e que o node está instaldo e pronto pra usar.
Crie um arquivo Javascript com o seguinte conteúdo:

var sys = require('sys'),
http = require('http');
http.createServer(function (req, res) {
        setTimeout(function () {
               res.writeHead(200, {'Content-Type': 'text/plain'});
               res.write('Hello World');
               res.close();
        }, 2000);
}).listen(8000);
sys.puts('Server running at http://127.0.0.1:8000/');

Salve o arquivo com o nome que desejar dentro da pasta test que foi criada na raiz do node.
Para testar:

node nome_do_seu_arquivo.js

A mensagem no terminal deve ser essa: “Server running at http://127.0.0.1:8000/“

Acesse com o Browser o endereço para visualizar a aplicação Hello World em funcionamento.

Bom, com a breve introdução e com esse exemplo é possível ter uma ideia do que é nodeJS. O próximo passo é estudar a Documentação que é bem rica.
Fico por aqui, qualquer dúvida entrem em contato que tentarei ajudar.

Há tempos que penso em testar o nodeJS, mas só esta semana pude parar e dedicar um pouco de tempo a este obejtivo.
Meu intuito com este post é apenas “compilar” algumas informações sobre o node e passar adiante para aqueles que ainda não tiveram a oportunidade de conhecer.
O que mais me motivou a investigar o node, foi o próprio nome. nodeJS.
Assim como todo aficcionado por Javascript, sempre quero saber tudo a respeito da linguagem, assim como o que está sendo feito com ela.
O que mais me chamou a atenção foi o termo: “Server-side Javascript“. \o/
Sim, isso mesmo. Javascript rodando no servidor.
O que me expantou também foi o fato de existirem várias implementações deste tipo, são quase 50 [Link acima].

Vamos então as características do nodeJS:

Interessado em aprender mais assim como eu?
Então, algumas referências:

Site do nodeJS
http://nodejs.org/#about

Módulo para rodar YUI dentro do node
http://yuilibrary.com/gallery/show/nodejs

Blog do Simon Willison falando sobre nodeJS

Slides JSConf
http://s3.amazonaws.com/four.livejournal/20091117/jsconf.pdf

Aplicação exemplo com o node
http://chat.nodejs.org/

Vídeo com Ryan Dahl falando sobre o node em SãoFrancisco em janeiro deste ano

NodeJS Synoposis from Kris Kowal on Vimeo.

No próximo post mostrarei  um passo a passo de como instalar o nodeJS e como fazer um “Hello World”.  :P

Atualmente o TheWebMind encontra-se na versão Pre-Alpha, isso quer dizer que ainda não está totalmente estável, ainda possui bugs e melhorias a serem implementadas.
Mas com o que temos hoje, é possível fazer muita coisa. E é isso que quero compartilhar.

Parto do princípio que quem estiver seguindo o tutorial já saiba o que é o TheWebMind, e conheça a teoria por traz de tudo.
Caso contrário acesse a página da documentação: http://docs.thewebmind.org/index.php?title=Main_Page

Minha proposta é criar um sistema simples de tarefas.

Requisitos:
O sistema deve permitir o cadastro de usuários.
O usuário deve ter nome.
A tarefa deve possuir título, descrição, data e um usuário vinculado.
O sistema deve permitir o cadastro de várias tarefas para um usuário.
O sistema deve possuir interface para edição e visualização dos dados, tanto de usuários como de tarefas.
Resumindo, é um sistema bem simples, onde o usuário cadastra suas tarefas.

Passo 1 – Criando um projeto no TheWebMind

Para criar um projeto, acesse o menu File > New Project e preencha os dados do projeto.
OBS: Certifique-se de que você tem um banco de dados instalado e configurado  no seu server, e preencha corretamente os dados, informando o endereço, nome, porta, usuário e senha do banco de dados.
São estas informações que o TheWebMind utiliza para gerar as tabelas.

Passo 2 – Escrevendo em WML

Criado o projeto, vamos escrever o código WML que atenda aos requisitos.
A sintaxe da linguagem WML é baseada no conceito NLP (Natural Language Processing), que consiste basicamente em ser semelhante a linguagem humana natural(Português, Inglês, Espanhol, etc).
Veja mais detalhes na documentação: http://docs.thewebmind.org/index.php?title=Web-Mind-Language

<br /><br />Sabemos que o usuario tem nome:string(100);<br />A tarefa tem título:string(100);<br />A tarefa tem descrição:text();<br />A tarefa tem data:date();<br />O usuario tem tarefa;<br /><br />

Passo 3 – Visualizando as saídas

Clique no botão localizado na barra de tarefas acima do editor.

Depois de “compilado” o projeto, você poderá ver as saídas como diagrama ER, Dicionário de dados, e o código SQL no painel de abas logo abaixo do editor.

Passo 4 – Gerando o projeto

Para gerar o projeto clique  no botão também localizado na barra de tarefas acima do editor.
Uma tela de Wizard abrirá, guiando o usuário até o final.
No Step 1 selecione a segunda opção, que indica o banco de dados de desenvolvimento previamente cadastrado na tela de criar o projeto.
Avance para o próximo passo clicando no botão Next.
Uma tela com todos os módulos será exibida no Step 2, selecione o ZendModels e avance para o próximo passo.
No Step 3 existem 2 opções relacionadas ao que o TheWebMind irá fazer em relação ao banco de dados.
Esta opção deve ser cuidadosamente selecionada, pois se você selecionar a opção “be replaced” , o TheWebMind irá deletar a tabela existente, assim como todos os seus dados e criará uma nova com as alterações necessárias.
A opção “be skipped” ignora qualquer alteração na base de dados.
Agora clique em Finish, e acompanhe a tela onde o TheWebMind mostra tudo que está acontecendo, como cópia de arquivos necessários, criação de tabelas, etc.

Pronto. Você acabou de criar um sistema com o TheWebMind.

Passo 5 – Visualizando o projeto gerado

Feito todo o trabalho, o TheWebMind irá exibir a mensagem “Finished, the project’s been generated here“.
Uma tela com a arvore de arquivos gerados será exibida. É possível ver o conteúdo de um arquivo ao seleciona-lo.
Acima da árvore, clique no botão “Explore Files” , este o conduzirá até a página onde a Aplicação foi gerada.

Passo 6 – Testando a Aplicação

Seguindo esses passos temos um simples sistema de tarefas funcionando.
Para testar publiquei a aplicação gerada aqui: http://source.jaydson.org/TaskList/
O ZendModels gera os formulários da aplicação, isso serve para testarmos se tudo esta funcionando corretamente.

Bom, este foi um pequeno tutorial de como fazer um sistema simples com o TheWebMind utilizando o ZendModels.
Qualquer dúvida entrem em contato ou comentem.
Abaixo segue o link para download da aplicação gerada no exemplo, mas para um melhor entendimento do TheWebMind sugiro que vocês façam o download do TheWebMind, e sigam todos os passos descritos acima.
É muito fácil.

Download:  http://source.jaydson.org/TaskList.rar

Vejam um outro exemplo no blog do @felipenmoura : http://felipenascimento.org/en/portugues-brasil-criando-uma-aplicacao-funcional-com-thewebmind/

O projeto vem crescendo ao longo dos meses, e 2010 promete ser um ano de muito sucesso.
Desenvolvedores espalhados pelo Brasil e pelo mundo estão entrando em contato conosco mostrando interesse em participar de alguma maneira do TheWebMind.
Aos poucos estamos nos organizando e selecionando pessoas engajadas que possam contribuir.

Semana passada foi um marco para o TheWebMind. Finalmente depois de muito trabalho, liberamos a versão Pre-Alpha 2.0.0.
Está versão esta totalmente diferente da 1° versão lançada em 2009.
Reescrevemos praticamente todo o core e reformulamos totalmente a interface.
Construímos um novo módulo(ZendModels) que gera código PHP baseado no Zend Framework.

Bom, aos interessados segue abaixo o link para download:
http://thewebmind.org/download_latest

Nas próximas semanas pretendo postar exemplos práticos de uso do TheWebMind,  principalmente usando o ZendModels para geração de código.