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.

Com este guia você tem todas as funções jQuery reunidas em um só lugar. Adicionei também um exemplo básico da utilização/marcação/sintaxe da biblioteca. Você pode baixar também a versão em PDF para imprimir e carregar no bolso

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