DGmike

Sei, o projeto está um pouco deixado de lado, mas este ano tem sido muita correria e nos momentos de desespero o CodeIgniter tem sido o meu framework padrão. Acontece que fiz uma busca na internet e encontrei um projeto chamado Internet Communications Engine – ICE, que faz parte da familia ZeroC e suporta PHP. Para não haver confusão, decidi trocar o meu humilde projeto de framework. Agora ele deixa de se chamar Ice e passa a se chamar Ice-Baby, em homenagem a uma música que gosto pra caramba do Vanilla Ice.

http://www.youtube.com/watch?v=h4v5MeJ5fVg

Na minha última palestra (PHP Minas) eu apresentei um microframework e ele me serviu de rascunho para o novo Ice-Baby. Talvez mantenha alguma coisa do Banco de dados do antigo Ice, mas provavelmente tudo irá mudar.

Alguns conceitos de MVC devem ser abstraidos quando você for usar o framework já que ele não exige uma estrutura lógica como a maioria dos frameworks por aí. Ao invés de você ter que pensar URL com arquivo, com classe e com método e assim por diante você deve pensar em mapear uma ou mais URLs e direcioná-las para a classe desejada. O método que ele irá usar é o método no qual o usuário chegou na página (get/post). Simples, né?! E os parâmetros, você decide o que é parâmetro também Veja um exemplo de código de como sua aplicação pode ficar:

1
2
3
4
5
6
7
8
9
10

<?php
require_once('appropriate/app.php');
 
app(array('^.*$' => 'Welcome'));
 
class Welcome {
  function get() {
    print 'Hello from Bahamas!';
  }
}

Sim! Você consegue escrever uma aplicação com apenas dez linhas de código.

No momento estou me concentrando a escrever a parte do Framework que conversa com o banco de dados (Models e seus resultados). Quem quiser acompanhar o desenvolvimento da ferramenta, pode acompanhar no github, dessa vez vai!

Quem quiser, pode usar outro framework enquanto o Ice-Baby não sai do Beta. Recomendo o Vórtice, Spaghetti e CodeIgniter. Os motivos pelos quais eu escolhi estes frameworks para indicar e não outros? Liberdade! Eu gosto de escrever código da forma que eu quiser sem ter que aprender muito para começar a usar uma ferramenta.

Estava fazendo alguns testes com PDO e SQLite e descobri uma coisa muito interessante sobre o PDO: classe de resultados. O que isso quer dizer, que quando você faz um fetchObject você pode usar sua própria classe com seus próprios métodos.

Atenção! Este post é totalmente NERD e destinado para programadores com algum conhecimento em PHP e banco de dados. Caso este não seja seu perfil aconselho a desistir enquanto é tempo.

O código começou mais ou menos assim, eu queria desenvolver um model específico para o ICEPHP, e com o advento do PDO decidi usá-lo como base. Então precisei de alguns definitions: diretório onde se encontra o arquivo (script) e o separador de pastas que em linux é barra e no windows é contra-barra. Também criei duas tabelas no banco de dados, post e categoria:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

define('DS', DIRECTORY_SEPARATOR);
define('ICE_DIR', dirname(__FILE__));
 
$bd = new PDO('sqlite:'.ICE_DIR.DS.'banco.db');
# A conexão do PDO não é linda?!

$bd->query("
    CREATE TABLE IF NOT EXISTS categoria (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        nome VARCHAR(40),
        slug VARCHAR(40)
    );
");
$bd->query("
    CREATE TABLE IF NOT EXISTS post (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        titulo VARCHAR(40),
        slug VARCHAR(40),
        post TEXT,
        data TIMESTAMP
    );
");

Após isso fiz um select no banco de dados e se não me retornasse resultados, inseri um dado no banco de dados:

1
2
3
4
5
6
7
8
9
10
11
12

$c=$bd->query("SELECT COUNT(*) as c FROM post;");
 
if (!$c->fetchObject()->c) {
    $bd->query("
        INSERT INTO post (titulo, slug, post, data) VALUES (
            'Apenas um teste',
            'apenas-um-teste',
            'Este post é apenas um teste do novo Framework: ICEPHP',
            CURRENT_DATE
        );
    ");
}

Com isso eu consigo usar o resultado de forma linda (orientado a objetos):

1
2
3
4
5

$c=$bd->query("SELECT * FROM post;");
$r = $c->fetchObject();
echo $r->titulo;
 
// Isto retorna "Apenas um teste"

Lendo a documentação sobre o fetchObject do PDO vi que é possivel passar como parâmetro uma string com o nome da Classe que você deseja que seja utilizado para o resultado, lembrando que (!), o padrão é o stdClass. Entao passei minha classe resultado como exemplo e o que descobri. Coisas lindas de se fazer. Eis a classe Resultado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

class Resultado
{
    var $_data = array();
    var $_updated = false;
 
    function __toString()
    {
        return "O resultado é: ".$this->titulo . ' ('.date('d-m-Y h:i:s', $this->data).")\n";
    }
 
    function __get($k)
    {
        return $this->_data[$k];
    }
 
    function __set($k, $v)
    {
        if (isset($this->_data[$k]) AND $this->_data[$k] != $v) {
            $this->_updated = true;
        }
        $this->_data[$k] = $v;
    }
 
    function salvaPost()
    {
        global $bd;
 
        $sql = "UPDATE post SET ";
        foreach ($this->_data as $k=>$v) {
            if ($k!='id' || $k != 'data') {
              $sql .= "\n  $k = '$v',";
            }
        }
        $sql = substr($sql, 0, -1);
        $sql .= "\n WHERE id = ".$this->id;
 
        $bd->query($sql);
    }
 
    function __destruct()
    {
        if ($this->_updated) {
            $this->salvaPost();
        }
    }
}

Veja, apenas usei um método de verdade, todos os outros usei os métodos mágicos do PHP (__toString, __get, __set, __destruct). Recomendo que leia sobre estes métodos e use-os, eles podem salvar sua vida. Whatever, com essa classe Resultado é possivel fazer o que eu sempre quis fazer, um objeto de resultado de banco de dados que atualiza o banco sem usar o estilo seta parametros e depois salva. Veja como é feito na maioria dos ORMs por aí:

1
2
3

$r=$post->get(1);
$r->titulo = 'Titulo Alterado';
$r->save();

Pense comigo, se você atribuiu um valor, você quer que ele seja salvo, correto? Então não ficaria mais fácil se forsse assim?

1
2

$r=$post->get(1);
$r->titulo = 'Titulo Alterado';

Sim!!! Às vezes você atribui um valor que não deseja salvar, faz isso apenas para configurar os dados e etc, mas pense, quantas vezes você faz isso? Além disso, óbvio que é possivel fazer tudo o que deseja gastando um pouco mais de massa cinzenta, mas a proposta não é essa no momento.

Usando a classe Resultado é possivel fazer o update quase que “on the fly”. Na verdade, para o programador parece que é instantâneo, mas não é. O update se dá no destruct do objeto, normalmente quando o script finaliza, mas pode ser quando damos um novo fetchObject nessa variável. Se ele não for alterado ele, obviamente, não salva as alterações no banco de dados. Veja como fica o exemplo do que estou falando.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

$c=$bd->query("SELECT * FROM post;");
# Pegando o objeto e jogando-o na classe de resultados
$r = $c->fetchObject('Resultado');
 
# Imprimindo, devido ao método __toString aparece:
# O resultado é: Apenas um teste (31-12-1969 09:33:29)
print ($r);
 
# Alterando o resultado
$r->titulo = 'Teste';
 
# Imprimindo mais uma vez, aparece
# O resultado é: Teste (31-12-1969 09:33:29)
# mas isto está em 'cache'
print ($r);
 
# Quando o objeto é destruído, ao finalizar o script
# ele faz o update necessário

Testei isso no foreach e também funcionou, então é fazer updates de objetos em escala, mas não exagere, o ideal é fazer isso no sql. Veja como fica com o foreach:

1
2
3
4
5

$c=$bd->query("SELECT * FROM post;");
 
while ($x = $c->fetchObject('Resultado')) {
    $x->data = time();
}

Isso me deixa com várias ideias para criar o ORM do ICEPHP. Mas fica a dica para vocês desenvolverem seus códigos, experimente criar um método FORM que já cria um formulário html para você facilitar sua vida.

Mudanças sempre são boas. Mesmo que a gente passe por momentos ruins a gente sempre aprende muita coisa com mudanças.

Este ano está sendo um ano muito louco e cheio de mudanças para mim. No final do ano passado o @elcio me convidou para fazer parte da familia visie. De lá para cá muita coisa mudou. Aprendi a linguagem python, mudei do Rio de Janeiro (Campos para ser mais exato) para São Paulo (capital), fiquei um tempo de favor na casa do meu amigo @rzamana. Comecei a desenvolver o IcePHP que, um dia se Deus quiser, vou concluir. Fui a ótimos eventos de web, infelizmente alguns não tinham internet liberada. Adiquiri um belo laptop cce que estou levando para todos os lados. Assisti meu primeiro filme em 3D, o que foi o máximo.

Nestes últimos meses tenho passado por momentos de muito sobe e desce. Primeiro, escrevi um artigo para uma revista e agora há pouco comecei a escrever para um site que eu sempre fui fã, um site onde eu praticamente aprendi a escrever de verdade. Com ajuda do Elcio fiz um projeto muito legal em python, onde o pessoal está aprendendo um bocado sobre python, ajax, tableless, javascript.

Também conheci um carinha muito legal que me ensinou algumas coisas sobre a vida. Hoje sei muito bem que as coisas não são caras, elas tem o valor que devem ter, basta não exagerar na dose. No bar, uma cerveja não é para beber até cair no chão sem noção do que pode acontecer, mas simplesmente degustar o belo sabor que a bebida tem.

Não foram apenas mudanças em minha vida, mas na vida das pessoas que estão ao meu redor também mudou muita coisa. Alice, por exemplo passou um tempo desempregada, fazendo um monte de entrevistas, entrou em uma empresa onde ela aprimorou, e muito, sua escrita e semântica. Esta semana ela está em uma empresa nova, não na área que ela gosta, mas com boas chances de crescimento em outras áreas. E o mais legal é que ela conseguiu todos esses meritos sem ajuda de ninguém, muitas vezes nem minha, devido a minha falta de tempo.

O rafael também mudou duas vezes de emprego, trabalhou em uma empresa grande e hoje está melhor colocado em outra empresa. Não tão grande quanto a outra, mas o importante é que está feliz fazendo o que melhor sabe fazer. Ah sim, ele também escreveu um ou outro artigo.

A visie também mudou, não só fisicamente mas estruturalmente, o campus mudou, o site mudou, a equipe mudou e até contratamos um carinha lá do Rio, que está de mudança para cá.

Fiquei muito tempo sem postar no meu blog por conta de tantas mudanças, mas estou voltando com muitas novidades, muita coisa nova que aprendi durante esse tempo off. Primeiro, o meu blog mudou. Não só de layout como era costume, mas de endereço também. Estou com um servidorzinho onde o ponto vermelho está alocado e também estou entrando no ramo de aluguel, ainda não tenho valores mas em breve teremos mais detalhes. Me segurem, esta nova fase não vai ser mole!!!

Estou desenvolvendo meu próprio framework para PHP: IcePHP. Como sempre gosto de começar pelo banco de dados, este é o primeiro lugar de onde a aplicação vai partir. Os unicos arquivos no repositório do projeto são de banco de dados além do começo da documentação do mesmo. Até agora, o banco só funciona com a extensão mysqli (mysql implemented do PHP), mas pretenderá extender-se a outros bancos desde que eu tenha necessidade de tais bancos ou mesmo as pessoas que quiserem ajudar.

O IcePHP será um framework para projetos simples, sites simples ou mesmo blogs ou pequenos portais de conteúdo, já que terá integrado em sua engine um sistema de cache. Não! O IcePHP não é um CMS é um FrameWork que poderá desenvolver todos esses tipos de sistemas.

Vamos a um exemplo simples, de como a classe de banco de dados se comporta. Faremos um simples blog. Mostrando os itens de uma determinada categoria. Então, este é o nosso banco de dados:

CREATE TABLE categorias (
id int(5) NOT NULL,
nome varchar(255) NOT NULL,
PRIMARY KEY (id)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

CREATE TABLE IF NOT EXISTS `posts` (
`id` int(5) NOT NULL,
`categoria_id` int(5) NOT NULL,
`titulo` varchar(255) NOT NULL,
`post` text NOT NULL,
`data` date NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

Duas tabelas simples com poucos campos, que são a maioria dos casos que temos nos projetos diários. Agora, vamos à classe banco. Primeiro, conectamos ao banco.

require_once ("banco.php");
$banco = new banco ('mysqli://root:123456@localhost/icephp');

Na primeira linha, fiz o requerimento do arquivo (require_once para não chamar o arquivo duas vezes se ele tiver sido chamado antes), e na segunda linha a coneção através de uma url simples onde coloco o driver, usuario, senha, url do banco (localhost) e o banco (icephp).

Isto fará com que minha instancia $banco receba dois objetos (as tabelas) então posso chamá-las assim:

$banco->categorias;
$banco->posts;

Cada uma delas possui uma série de funções como novo(), get(), select() e por aí vai (ainda não está totalmente pronta, por isso só tem o get). Que me auxilia da seguinte forma. Digamos que queremos o primeiro post da tabela.

$post = $banco->posts->get(1);

Agora, post é um objeto tabela que tem os dados que queriamos. Logo, podemos pegar as seguintes informações.

$post->id;
$post->titulo;
$post->post;
$post->data;
$post->categoria;

Categoria?! Sim, a classe banco já instancia a categoria atraves de um belo join implicido ao criar um campo com a sintaxe NomeDaTabela_id. post->categoria é um objeto tabela que pode ser retirado as seguintes informações.

$post->categoria->id;
$post->categoria->nome;

Agora, faremos o procedimento contrário. Vamos pegar uma categoria com o método get.

$categoria = $banco->categorias->get(1);

Agora $categoria tem as seguintes propriedades:

$categoria->id;
$categoria->nome;
$categoria->posts;

Sim! Ele faz o inverso também! Temos um array de tabelas posts com os posts continos nessa categoria. Agora, vamos a um exemplo bem prático, vamos listar os posts da 3ª categoria:

foreach ($banco->categorias->get(3)->posts as $post) {
printf ('
<h1>%s</h1>
<p>Postado em %s na categoria %s</p>
<p>%s</p>
', $post->titulo, $post->data, $post->categoria->nome, $post->post);
}

Como vocês podem ver, a classe banco resolve muitos problemas de uma vez só, basta usá-la com conciencia.

Estava querendo começar a desenvolver um framwork de verdade há um bom tempo, mas nunca conseguia me agradar o suficiente (nossa!). Cheguei a montar um pseudo framework, o frwk-br, mas tinha um nome muito complicado de decorar.

Para o IcePHP vou me basear bastante no frwk-br e em algumas coisinhas que aprendi no curso de Python que fiz recentemente com o Elcio da visie. Espero que o IcePHP não fique guardado na geladeira e seja usado por várias pessoas no seu dia-a-dia.

Para este trunfo, conto com a ajuda do meu amigão Zamana, que está sempre bisbilhotando meus códigos indicando onde tem erros (isso é bom). ;D