Se você instalou o seu apache pelo gerenciador de pacotes do linux, seja pelo synaptic ou via apt-get faça o seguinte:

sudo cp /etc/apache2/mods-available/rewrite.load /etc/apache2/mods-enabled/

Este comando irá copiar o módulo rewrite da pasta de módulos disponíveis para os habilitados, depois faça o seguinte:

sudo gedit /etc/apache2/sites-available/default

Este arquivo que estamos editando, o default, possui as configurações relacionadas a pasta raiz do seu servidor. Para habilitar o mod_rewrite para a raiz encontre a configuração referente a pasta /var/www e altere a linha abaixo:

Options Indexes FollowSymLinks MultiViews
AllowOverride None

para:

Options Indexes FollowSymLinks MultiViews
AllowOverride All

Pronto, já é o suficiente para habilitar o mod_rewrite. Agora basta reiniciar o apache:

sudo /etc/init.d/apache2 restart

Já neste artigo falarei mais sobre sua sintaxe e semântica através de alguns exemplos e imagens.

Utilizarei, neste artigo, Ruby na versão 1.8.7 e a IDE NetBeans com suporte à Ruby.

versão do ruby

Linguagem

Para programar em Ruby você precisa ter em mente o motivo de sua concepção. Ruby foi desenvolvido para ser legível, tanto para programadores como para leigos. Com isso ele possui uma flexibilidade de escrita muito grande, mas vamos começar pelo básico:

Ponto-e-vírgula

O ponto-e-vírgula (;) é o separador clássico de instruções, em linguagens tradicionais cada fim de instrução é terminado com ponto-e-vírgula, mas qual a real necessidade disto?

Em geral separamos nossas instruções por quebra de linha. Como o Ruby é uma linguagem que privilegia a leitura, nada mais justo do que permitir que os ponto-e-vírgulas sejam retirados.

No começo pode parecer muito estranho, mas quando você começa a programar um pouco mais na linguagem você começa a pensar como isto não foi adotado em outras linguagens. E isso acontece em várias outras características de Ruby.

minha_string = nil

minha_string = "uma string qualquer"

puts minha_string

# uma string qualquer

No código acima, você pode perceber que no fim das instruções não existe ponto-e-vírgula, se você executar o código e a saída será o valor da string instanciada: uma string qualquer.

É claro que você ainda poderá usar o ponto-e-vírgula, caso você tenha a necessidade de colocar várias instruções na mesma linha, depende de sua convenção de código. Você pode codificar da seguinte forma:

minha_string = nil; minha_string = "uma string qualquer"

puts minha_string

# uma string qualquer

Parentesis

Por ser uma linguagem que tenta se aproximar bastante da linguagem natural as chamadas de método se tornam bastante flexíveis.

No exemplo abaixo criei uma classe Pessoa onde informo o nome e o sobrenome. Abaixo a chamada de método em sua forma normal:

Trecho de código 1

Para melhorar a leitura, podemos retirar os parentesis. Da seguinte forma:

Trecho de código 2

Viu, muito mais simples desta forma, certo!?

Os casos mais conhecidos são os jar’s e war’s do java para, no caso do jar, executar aplicações e distribuir bibliotecas e o war para facilitar o deploy no servidor web.

Também podemos citar os gems do ruby que é uma forma de distribuir bibliotecas e aplicações.

O PHP não é diferente. Na versão 5.3 foi implementado nativamente o suporte aos arquivos phar (coincidência?), antes disso uma extensão da pecl era utilizada para criar os arquivos.

Com os arquivos phar, podemos criar bibliotecas, compactá-las e aproveitar as mesmas em nossos projetos de uma maneira mais clara e inteligente, afinal, em um projeto não precisamos saber onde as classes de terceiros (ou não) estão, apenas precisamos saber que estão lá e como chamá-las para atender nossas necessidades.

Diferente do java em que a IDE, ao fazer o build, automaticamente gera um jar com os fontes e as bibliotecas necessárias (graças ao ant). No PHP temos que criar nosso próprio script para que o phar seja gerado. Em outras palavras, o phar será gerado manualmente. Estes passos podem ser automatizados, claro.

Neste exemplo usarei uma classe simples para gerar o phar, trata-se de uma classe que armazena uma string para encriptação. O código da classe é esse:

<?php
namespace com\pedrojannotti\model;

/**
 * Description of MD5
 *
 * @access public
 * @package model
 * @subpackage security
 * @version 1.0
 *
 * @author Pedro Jannotti <http://pedrojannotti.com>
 * @see http://pedrojannotti.com
 * @since 13/02/2010
 */
class MD5 {
    private $encriptedString;
    public function __construct($string) {
        $this->setEncriptedString(md5($string));
    }

    public function getEncriptedString() {
        return $this->encriptedString;
    }

    private function setEncriptedString($encriptedString) {
        $this->encriptedString = $encriptedString;
    }
}

Bom, com a classe base para o nosso phar pronta, vamos criar agora o script que permite que o arquivo phar seja gerado.

Criarei um arquivo chamado create.php que poderá ser acessado tanto via apache como por linha de comando.

$phar = new Phar('aplicacao.phar');
$phar->startBuffering();
$phar->buildFromDirectory('/var/www/phar1');
$phar->stopBuffering();

O script acima cria um objeto do tipo Phar que recebe em seu construtor o nome do arquivo phar a ser gerado.  A extensão .phar deve ser informada, pois esta compactação também pode gerar arquivos de outros formatos.

A segunda linha do script inicia a gravação iniciando o buffer.

Na terceira linha é onde definimos quais arquivos deveremos incluir no phar. No meu caso, para facilitar, estou criando o meu arquivo phar baseado em um diretório. Utilizando o método buildFromDirectory o objeto busca os outros arquivos de forma recursiva.

A criação do phar pode utilizar vários outros métodos, como addFile, addEmptyDir. Para conhecer todos basta acessar a documentação do phar em http://php.net/manual/en/book.phar.php.

Após a execução do script o arquivo será gerado. Para incluir o arquivo phar em sua aplicação, basta usar o comando require da seguinte forma:

require_once 'phar://aplicacao.phar/';

Se você executar este arquivo em um browser ou em linha de comando você deverá ver a mensagem “hello world” impressa na tela. Isto acontece pois quando estávamos criando o phar não informamos qual seria o arquivo de inicialização do phar, ou seja, qual arquivo deverá ser chamado ao importar o phar no projeto (bootstrap).

Para fazer isso, nosso script de geração do phar mudará um pouco:

$phar = new Phar('aplicacao.phar');
$phar->startBuffering();
$phar->buildFromDirectory('/var/www/phar1');
$phar->setDefaultStub('src/main/php/com/pedrojannotti/model/MD5.php');
$phar->stopBuffering();

O stub do phar é o arquivo de boot ao importar o phar, é ele que será chamado ao importar o phar em seu projeto.

Gere novamente o arquivo e tente requerer novamente o arquivo. Você verá que nenhuma mensagem será exibida em tela.

Para usar a classe agora basta instanciá-la:

<?php
require_once 'phar://aplicacao.phar/';

$md5 = new \com\pedrojannotti\model\MD5("teste");
echo $md5->getEncriptedString();

Ruby

Ruby é uma linguagem de programação que foi desenvolvida nos anos 1990 no Japão. Desde então vem ganhando grande visibilidade, principalmente nos últimos tempos com a grande adesão dos profissionais que trabalham com metodologias ágeis e também de muitos profissionais que trabalham com a linguagem Java.

A linguagem Ruby é simples e bastante intuitiva. Sua sintaxe foi desenvolvida primeiramente para facilitar a leitura do código, tornando dessa forma uma linguagem bastante flexível à escrita.

Ao abrir códigos-fonte Ruby você irá notar que em muitos casos existem ausências de parêntesis e chaves, estruturas de controles mais simples e fáceis de entender, ausência dos famosos ponto-e-vírgulas (;) para término de sentenças. Tudo isto para deixar a linguagem mais parecida com a linguagem do mundo real.

Ruby é uma linguagem totalmente orientada à objetos, desde o mais simples operador tudo gira em torno de objetos:

Código-fonte Ruby

No exemplo acima se pode ver uma string sendo impressa no formato de letra maiúscula (puts imprime a saída). A classe de um número comum (Fixnum) e uma lista de todos os métodos do número, podendo dar destaque aos operadores de soma (+), subtração (-), multiplicação (*), entre outros métodos.

Ruby on Rails

No ano de 2005 foi lançada a primeira versão do framework para desenvolvimento web Rails. Esse framework foi fundamental para a grande aceitação da linguagem por toda comunidade. Trouxe consigo um novo padrão de desenvolvimento com sua ideia de “Convention over configuration” (Convenção sobre configuração) que influenciou grande parte das linguagens de programação atual.

Rails ganhou o carisma dos profissionais que trabalham com metodologias ágeis pela sua facilidade e rapidez no desenvolvimento de aplicações web.

Instalando Ruby

Ruby é uma linguagem de fácil instalação tanto em ambiente windows como Linux. Como tenho preferência pelo ambiente Linux, instalarei a linguagem e o seu interpretador no Ubuntu 10.04. Utilizarei a versão recomendada da linguagem, a versão 1.8.

No Ubuntu, esta versão do Ruby pode ser encontrada no repositório da distribuição. Então basta usar o comando apt-get install para instalar o Ruby.

Este comando pode ser encontrado também no site da linguagem nas instruções de instalação: http://www.ruby-lang.org/pt.

sudo apt-get install ruby irb rdoc

Para verificar se a instalação foi concluída com sucesso basta digitar no terminal:

ruby –version

Se for impresso no terminal a versão do Ruby 1.8.x quer dizer que a instalação foi completada com sucesso.

Nos próximos posts falarei mais sobre a programação com Ruby.

Até

Sobrecarga é um polimorfismo Ad-hoc, onde vários métodos possuem o mesmo nome mas a sua assinatura é diferente. Para saber mais sobre o conceito de polimorfismo consulte o link: http://pt.wikipedia.org/wiki/Polimorfismo.

Este é um conceito bastante útil e interessante, sua utilização, porém, gera sempre polêmica e deve ser usado com muito cuidado, pois o uso exagerado pode deixar o seu código complicado de se entender.

A implementação dessa especificação (sobrecarga) da orientação à objetos não é realizado em todas as linguagens e como é de se esperar o PHP também não a implementa, muito por causa de sua natureza bastante dinâmica combinado com sua tipagem fraca.

Mas então, se esta especificação não é implementada no PHP como poderemos utilizar?

Gostaria de lembrar que isto não é nenhuma novidade e já foi largamente abordado em outros blogs e fontes de dados pela internet a fora então, não se decepcionem.

Bom, o PHP nos dá três métodos que “auxiliam” a criação de uma sobrecarga. Ela não é natural, mas ainda assim pode ser realizada. Os métodos são: func_get_arg, func_get_args, func_num_args.

func_get_arg

Esta função permite que você recupere o valor de um argumento passado como parâmetro na chamada do método.

public function sobrecarga() {
    return $argumento = func_get_arg(0);
}

func_get_args

Esta função retorna um vetor com todos os argumentos passados como parâmetro na chamada do método.

public function sobrecarga() {
    var_dump(func_get_args());
}

func_num_args

Esta função retorna um inteiro que representa a quantidade de argumentos passados como parâmetro ao seu método.

public function sobrecarga() {
    return $quantidade = func_num_args();
}

Bom, e agora? Vamos à sobrecarga

Agora que já foram mostrados as funções que serão utilizadas vou mostrar, por código, como se implementa a sobrecarga no PHP.

A sobrecarga que irei mostrar será de dois tipo: sobrecarga por quantidade de parâmetros e sobrecarga por tipo de parâmetros.

Sobrecarga por quantidade

Para implementar este tipo de sobrecarga, basta escrever um método (sem argumentos) e na implementação deste método o método func_num_args será chamado para verificarmos com quantos parâmetros estamos trabalhando.

class Sobrecarga {
    public function sobrecargaUm() {
        if (func_num_args() == 2) {
            $this->_metodoChamadoComDoisArgumenos(
                func_get_arg(0), func_get_arg(1)
            );
        } else if (func_num_args() == 3) {
            $this->_metodoChamadoComTresArgumentos(
                func_get_arg(0), func_get_arg(1), func_get_arg(2)
            );
        } else {
            throw new Exception("Número de argumentos inválido");
        }
    }
}
$sobrecarga = new Sobrecarga();
$sobrecarga->sobrecargaUm("Hello","World");
$sobrecarga->sobrecargaUm("Hello","World", "Again");

Sobrecarga por tipo

Para implementar este tipo de sobrecarga basta recuperar os argumentos passados por parâmetros e testar o tipo de cada um deles.

class Sobrecarga {
    public function sobrecargaDois() {
        if (func_num_args() == 1) {
            if (is_numeric(func_get_arg(0)) {
                $this->_metodoSeArgumentoNumerico(func_get_arg(0));
            } else {
                $this->_metodoSeArgumentoString(func_get_arg(0));
            }
        } else {
            throw new Exception("Número de argumentos inválido");
        }
    }
}
$sobrecarga = new Sobrecarga();
$sobrecarga->sobrecargaDois("Hello");
$sobrecarga->sobrecargaDois(21);

Devemos usar?

Bom, como vocês podem notar, isto não é uma implementação natural. Foram utilizados meios para fazer com que a sobrecarga seja válida, a opção para o uso é de quem programa e com certeza a linguagem deve ser aproveitada em todo seu potencial.

Mas ao mesmo tempo, como é bastante perceptível, a implementação de uma sobrecarga deixa o código “feio” e difícil de ser compreendido, além de existir a necessidade de fazer vários testes para a chamada de um simples método. Isto faz com que sua aplicação fique mais propensa à erros.

A recomendação em geral é para que cada método possua sua própria assinatura única, este tipo de sobrecarga deve ser usado somente em casos extremamente necessários (isso varia com o bom senso do programador).

Mas fica uma dica importante, em caso de utilização de sobrecarga (ou mesmo sem utilizá-la) comente seu código com docblocks. Já que a assinatura do método não é completa (os argumentos não são descritos), facilita, com a leitura do comentário, descobrir o comportamento do método.

Sei que estou meio em falta, muito tempo que não posto nada, mas estes tempos tem sido de muito aprendizado, novas linguagens (ruby e java), novas propostas e novas oportunidades.

Espero que este novo ano seja muito proveitoso para todos e traga muitos desafios a serem vencidos, pois sem desafios todos paramos de nos mover e todos queremos evoluir, certo?

Um abraço a todos e prometo que vou tentar postar mais que no ano que passou.

Projetos de desenvolvimento de software são complexos. Anos de engenharia de software nos ensinaram que fazer e gerenciar grandes volumes de código é uma tarefa de grande dificuldade. Um dos motivos pelos quais desenvolvimento de sotware é uma atividade complexa se deve ao fato de ser uma atividade social, sim social. Grandes projetos são construidos pela colaboração de muitos desenvolvedores e os maiores avanços que em metodologias de software nos últimos anos se originam da aceitação de que se queremos melhores softwares devemos prestar maior atenção nas pessoas e não apenas no código.Uma maneira de entendermos a complexidade envolvida é visualizar a evolução de grandes projetos open source. Os logs de controle de versão são uma mina de ouro de informações para começarmos a entender as interações entre os desenvolvedores envolvidos e os projetos.

Code Swarm é um projeto open source para gerar visualizações de projetos de software pela análise dos logs de controle de versão. veja alguns exemplos:

code_swarm – Apache from Michael Ogawa on Vimeo.

Fonte em: http://escalabilidade.com/2010/10/11/visualizando-o-desenvolvimento-de-software/

Pensando neste problema é que foram adotadas algumas formas para deixar o desenvolvimento mais simples e separado das versões finais criadas da aplicação.

Muita gente utiliza este formato de desenvolvimento e é o padrão utilizado por diversas empresas do setor e também o padrão de versionamento do google code. Para quem não conhece clique no link: code.google.com.

Este padrão de desenvolvimento trata-se da separação de toda criação em 3 simples pastas: trunk, tags e branches ou tronco, etiqueta e ramo como está descrito no título do post.

O que é para que servem estas pastas está descrito logo abaixo:

branches: branches (ramos) é utilizado para o desenvolvimento livre, é um espaço onde você pode pegar o projeto que está desenvolvendo e aplicar novas idéias para ver no que acontece, pode ser fora do escopo do projeto inclusive. Normalmente são modificações feitas pelo próprio programador com funcionalidades que acreditam ser úteis ou pretendem testar em um projeto.

trunk: trunk (tronco) é utilizado quando o desenvolvimento do branches (ou não) já se torna mais sério ou atigindo mais o escopo do projeto. São versões, digamos, “mais profissionais” onde a idéia da implementação já está melhor definida e existe um caminho a seguir.

tags: tags (etiqueta) é destinado ao código-fonte final, a aplicação que está rodando no ambiente de produção do cliente. Esta versão deve ficar inalterada assim que uma nova versão é lançada, pois este representa o histórico de desenvolvimento da aplicação e não é destinada ao desenvolvimento.

Tags, trunk e branches na prática

Na prática esta estrutura de pastas são combinadas à um software que controla as versões geradas no sistema, existem vários no mercado, porém o que desponta é o Subversion. Para que não conhece: http://subversion.apache.org/.

Este software mapeia toda o seu código-fonte e salva em um repositório, quando você está em ambiente de desenvolvimento você só mexe em uma cópia de trabalho e depois envia ao servidor, o que torna bem mais simples o desenvolvimento colaborativo de aplicações.

Em outro post falarei mais sobre o controle de versão e seus principais comandos e funções.

No command não é importante como os objetos são chamados, pois todos os objetos são parametrizados implementando uma interface OO.

Implementando Command em PHP

A implementação do command é bem simples, seguindo os moldes da arquitetura MVC ele estará situado no controller e cada ação será chamado por um objeto que implementa uma interface Action.

Interface:

<?php
interface Action {
    public function execute();
}

Esta interface é responsável por parametrizar todas as ações do controller. Já que como não é importante saber sobre a instanciação da classe nós precisamos, ao menos, ter um ponto de partida padrão para que seja chamada nossa ação.

Esta nossa interface define o escopo da classe que implementará a interface, isto quer dizer que sempre que criarmos uma classe que implementa Action, a classe deverá possuir o método público execute().

Ação:

<?php
require_once 'Action.php';

class NovoUsuarioAction implements Action {
    public function execute() {
        // implementação da ação do método execute
        require_once 'view/FormNovoUsuario.php';
    }
}

Nossa classe que implementa o método execute realiza uma ação qualquer de fluxo e chama uma view correspondente.

Instanciando e controlando o fluxo das Actions

Agora vamos ver como faremos para instanciar nossas actions. Volto a repetir que como as actions são instanciadas não é importante, elas serão instanciadas automaticamente durante a execução da aplicação, mas, por não ser importante como são instanciadas, precisamos estabelecer um padrão para uma instanciação automática.

Para fazer isto vamos implementar uma classe Command (neste exemplo).

<?php
class Command {
    public function __construct($action) {
        require_once $action.'Action.php';
        $action .= 'Action';
        $obj = new $action;
        $obj->execute();
    }
}

Como podemos observar, a nossa classe Command recebe uma action e é ela que é responsável por fazer um require importando a classe e também instanciando e executanto o método execute que foi implementado anteriormente.

Para a action ser instanciada precisamos passar ao Command a action que deverá ser realizada, podemos fazer isto no index.php através de uma query string:

<?php
require_once 'Command.php';

$action = $_GET['action'];
$command = new Command($action);

Desta forma então, quando acessarmos a url http://seu.domínio/index.php?action=NovoUsuario a aplicação instanciará automaticamente nossa action, realizando as ações determinadas e chamando a view específica.

Neste caso estou utilizando a super-global $_GET para pegar a query string, para uma melhor segurança você poderia utilizar os filtros do php para sanitizar esta string e evitar problemas com quebra de segurança. Se você não conhece estas funções, basta dar uma olhada no manual do PHP na parte de Data Filtering.

Ao acessar o xml do feed era acusado um problema na geração devido à um espaço antes da marcação xml.

Existem plugins próprios para este tipo de verificação e algumas técnicas disponíveis na internet para retirar este espaço. Nenhuma destas alternativas deu certo.

A solução para este problema esta no próprio arquivo do tema do wordpress, mais precisamente no functions.php.

O problema eram sucessões de tags php abrindo e fechando (o problema era na tag de fechamento), como é documentado pelo PHP o fechamento de tag php pode acabar gerando um caracter em branco que, no meu caso, estava dando problema na geração do feed.

Bastou normalizar este arquivo que o feed voltou a ser gerado.