MonsenhorPublicado em 01/09/2010
Neste ensaio procuramos apresentar o desenvolvimento inicial do YAC, o CMS mais simples possível.
Um CMS básico e extensível para a comunidade de desenvolvedores perl. Ajude a realizar este trabalho!
Após diversos estudos escolhemos o framework Catalyst como base para todo o projeto por sua grande compatibilidade com as melhores práticas e ferramentas da programação moderna.
A melhor característica é a sua extensibilidade. Para criar uma extensão ou componente do Catalyst basta usar o Moose, um framework pós-moderno no paradigma POO, no CPAN.
Procuramos dividir o trabalho em 5 etapas:
Estudo dos CMSs em uso e suas características, objetivando encontrar lacunas e as principais demandas dos usuários. Definição dos primeiros cases, modelos e conceitos.
Passos básicos para o início de um projeto de acordo com as melhores práticas em perl
Usando os helpers do Catalyst implementar a estrutura básica do YAC
Arquitetura e orientações para extender o YAC.
Extender view e control implementando o plugin fckeditor
Um CMS (Content Management System) ou Sistema de Gerenciamento de conteúdo pode ser uma ferramenta web usada em alguns negócios na Internet para publicação e administração de multimídia. O líder deste mercado é certamente o Drupal, um CMS baseado em php, produto de referência usado por todos, considerado ferramenta chave na campanha de Obama à presidência dos Estados Unidos. O número de usuários do CMS Drupal ampliou consideravelmente (inclusive como escolha de designers e desenvolvedores), assim como o número de contribuições provindas da comunidade, um grande esforço de programação fruto da demanda significativa por estes códigos devido ao seu sucesso.
Geralmente a multimídia servida em um CMS precisa se integrar com outros sistemas como CRMs, ERPs ou outros sistemas legados da empresa. A maior oportunidade em CMS's para programadores está justamente no desenvolvimento destas ferramentas de integração, sistemas de plugin e extensões. Este é o caso do Drupal. Sua simplicidade minimalística é seu maior valor. Programadores podem desenvolver ganchos de seus sistemas no CMS e usuários finais podem plugá-los no website instantaneamente.
O segredo: O designer (ou qualquer um) pode criar um website funcional sem qualquer código. Um CMS precisa de uma interface de usuário simples e clara. Mas a integração com outros sistemas, talvez o principal foco do desenvolvedor esteja nesta aplicação externa, precisa ser simples também. Resultado final: Produtividade.
Nos mundos Java, Python, Ruby e Asp encontramos similares: Typo, OpenCms, Django, Plone. Alguns simples, outros com mais recursos.
Python http://plone.org/
Uma das principais característica do Perl e eu diria uma virtude de qualquer pessoa inteligente é poder fazer a mesma coisa de diversas formas.
Entre as ferramentas Perl não podemos deixar de falar do MovableType. O YAC não é concorrente direto do MovableType, que se integra no Catalyst e da mesma forma irá integrar-se em nossa implementação. O paradigma do YAC é diferente pelo foco na simplicidade e minimalismo. Será tranquilo iniciar um projeto com YAC e integrar o MovableType a qualquer momento.
O projeto Catalyst seria muito enriquecido com esta distribuição. Um CMS básico e extensivel, com os olhos no usuário final e interfaces que podem facilitar também o trabalho dos desenvolvedores. Um CMS mais simples que Drupal mas com o poder do CPAN e do Catalyst.
Vamos considerar também a integração com as ferramentas perl disponívies via cpan como Reaction, Mojo e Dancer.
$> sudo cpan Catalyst
$> sudo cpan Catalyst::Model::DBIC::Schema
$> catalyst.pl YAC
$> cd YAC
$> ./script/yac_create.pl controller Edit
$> ./script/yac_create.pl controller Hack
$> ./script/yac_create.pl controller Admin
$> ./script/yac_create.pl view Stack TT
$> ./script/yac_create.pl view Back TT
Vamos implementar o modelo no banco de dados sqlite! Ideal para esta aplicação.
Mas poderíamos usar mysql, postgres ou outro banco qualquer que o perl suportar.
Preferimos o editor vim:
$> vi yac.sql
Edite o arquivo yac.sql e coloque o código abaixo:
--
-- Cria a base de dados mais simples possEvel para um cms
-- Tabelas: users e stacks
--
PRAGMA foreign_keys = ON;
-- stack_id aponta o stack pai ou 0 se stack raiz
CREATE TABLE stack (
id INTEGER PRIMARY KEY,
stack_id INTEGER,
content TEXT
);
-- 'stack_userr' E uma tabela relacionamento muitos-muitos entre stacks e userss
CREATE TABLE stack_user (
stack_id INTEGER REFERENCES stack(id) ON DELETE CASCADE ON UPDATE CASCADE,
user_id INTEGER REFERENCES user(id) ON DELETE CASCADE ON UPDATE CASCADE,
PRIMARY KEY (stack_id, user_id)
);
CREATE TABLE user (
id INTEGER PRIMARY KEY,
first_name TEXT,
last_name TEXT,
login TEXT,
password TEXT,
role INTEGER
);
---
--- Dados de exemplo
---
INSERT INTO stack VALUES (1, 0, 'Sou a index.tpage
menu');
INSERT INTO stack VALUES (2, 1, '
menu1');
INSERT INTO stack VALUES (3, 1, ' menu2');
INSERT INTO stack VALUES (4, 1, ' menu3');
INSERT INTO stack VALUES (5, 1, ' menu4');
INSERT INTO user VALUES (1, 'Greg', 'Bastien', 'greg@cpan.org', 'novasenha', 1);
INSERT INTO user VALUES (2, 'Sara', 'Nasseh', 'sara@pan.org', 'novasenha', 1);
INSERT INTO user VALUES (3, 'Christian', 'Degu', 'degu@cpan.org', 'novasenha', 1);
INSERT INTO user VALUES (4, 'Richard', 'Stevens', 'stev@cpan.org', 'novasenha', 1);
INSERT INTO user VALUES (5, 'Douglas', 'Comer', 'comer@gmail.com', 'novasenha', 2);
INSERT INTO user VALUES (9, 'Ricardo', 'Filipo', 'filipo@kobkob.com.br', 'novasenha',3);
INSERT INTO stack_user VALUES (1, 1);
INSERT INTO stack_user VALUES (1, 2);
INSERT INTO stack_user VALUES (1, 3);
INSERT INTO stack_user VALUES (2, 4);
INSERT INTO stack_user VALUES (3, 5);
INSERT INTO stack_user VALUES (4, 6);
INSERT INTO stack_user VALUES (4, 7);
INSERT INTO stack_user VALUES (5, 8);
Agora vamos criar a base de dados
$> sqlite3 yac.db ./script/yac_create.pl model YAC DBIC::Schema create=static dbi:SQLite:
$> ./script/yac_create.pl model YAC DBIC::Schema YAC::Schema \
create=static dbi:SQLite:yac.db \
on_connect_do="PRAGMA foreign_keys = ON"
A unidade básica do YAC é o Stack, um objeto com 3 métodos:
A url única deste stack. Acessar a url retornará o mesmo que o método content();
Os dados do conteúdo. Uma string. Provavelmente em html.
Array com os stacks contidos neste stack
Será possível herdar um Stack definindo-se novos métodos.
Além da interface default (Play), a máquina de estados do YAC apresenta ainda 3 outras interfaces.
Default, apresenta os Stacks.
Interface de edição de Stack.
Interface de desenvolvimento de Stack.
Interface de administração e gestão de usuários.
use YAC::Stack;
Instanciar um Stack:
my $coolStack = new YAC::Stack;
Montar o Stack, editando url e conteúdo
$coolStack->url ('my/coolStack');
my $url = $coolStack->url();
$html = "Oi gente!";
$coolStack->content($html);
Acessar o Stack na Web
use LWP::Curl;
my $browser = LWP::Curl->new();
my $hello = $browser->get('my/coolStack');
my $content = "$hello Benvindos ao YAC!";
Um Stack então pode ser apresentado, editado ou construído e é acessado em determinada url.
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
YAC (YACCMS (Yet Another Catalyst CMS))
Colofon:
YAC lembra "Yeast Artificial Chromosome. Yeah! A levedura é o nosso mascote. See http://en.wikipedia.org/wiki/Yeast
Versão 0.01
Monsenhor, <ricardo.filipo at gmail.com>
O CMS mais simples que existe.
use YACCMS;
my $web = new YACCMS;
$web->run();
# go to web!
O ponto de vista do usuário leigo é o foco do YAC. Eu não tenho dúvida que seria muito mais fácil para o nosso pequeno YAC se não tivesse que lidar com usuários. Especialmente os que são leigos nas aventuras da TI. Mas nada disto teria sentido se o YAC não fosse pensado para ser usado por alguém.
Na verdade se houver alguma complexidade no YAC estará relacionada com o desenvolvimento de interfaces e agentes voltados à facilidade do usuário. O nosso objetivo é permitir que o usuário pense e trabalhe em seus assuntos, sem ter que se preocupar com detalhes de como isto se realiza. Infelizmente o YAC ainda não pode entender o usuário por telepatia, sim, seria certamente a melhor abordagem caso já existisse a tecnologia, então nos contentaremos com as interfaces em uso, como Html e Ajax.
Produtos como Drupal, líder do mercado, apresentam, apesar de sua grande maleabilidade e integrabilidade com outros sistemas, uma interface engessada e ainda complexa para um usuário médio. A proposta do YAC é ser o mais simples possível, o mais básico possível. O objetivo do YAC é administrar apenas cada elemento unitário de cada vez. A unidade é o Stack.
Em nossa opinião o melhor desenho para um CMS deve ser a Pilha. Mas pensamos a pilha como uma colagem, os objetos não precisam ser todos da mesma forma material ou tamanho. A estrutura de camadas do css ou folhas de estilo funciona assim. Cada objeto depositado na pilha (a tela do site) é um url definido como um elemento do YAC, uma pilha de pilhas.
O nosso mascote, o fungo, apresenta uma estrutura muito parecida. Uma colônia de fungos forma desenhos, cores e formas de acordo com o ambiente. Cada pequeno fungo acha seu lugar e a pilha de fungos forma como que um indivíduo único, um local de vida, um site.
----------
| Stack |-----> URL # Tela do site
----------
| ----------
|----> | Stack |-----> URL # CabeEalho
| ----------
| | ----------
| |----> | Stack |-----> URL # Logomarca
| | ----------
| | ----------
| |----> | Stack |-----> URL # Menu
| ----------
| ----------
|----> | Stack |-----> URL # Texto em html
----------
Um Stack está relacionado a uma URL, retorna um array de Stacks e pode ser herdado e livremente modificado.
Cada Stack pode ser apresentado, editado ou construido (hack). Além disso um Stac possui um usuário responsável.
Retorna uma instância do controlador do aplicativo. Agora voê pode rodar ou parar o YAC.
Roda o daemon http na porta $port. Default em 80.
my $port = 80 ;
$web->run ($port) ;
$web->stop();
Para o daemon.
YAC - Baseado em Catalyst
script/yac_server.pl
O YAC pode carregar uma das 4 máquinas:
. Play
. Edit
. Admin
. Hack
Cada máquina exige que o usuário possua determinados função e direitos de acesso.
A Máquina Play ou controlador Root será sempre a default. Aqui o usuário poderá visualizar os conteúdos em mídia e acessar os menus básicos para navegação.
Um usuário logado com direitos de edição pode acessar a máquina Edit para editar seu trabalho.
O editor default é html. Outros editores como link, código, imagem, animaçã, xml, svg, json e outros podem ser adicionados como extensões.
O menu é o mesmo que o da máquina Play mais os menus de dados pessoais e de edição. Também serão acrescentadas interfaces para edição de dados pessoais e outros em extensões. Estes novos editores serão integrados na mesma interface.
Com direitos de administrador o usuário poderá acessar a máquina Admin.
Apresenta interfaces para editar e administrar usuários, seus dados e trabalhos. Permite atividades administrativas no CMS's como startup/shutdown do servidor e habilitar/desabilitar extensões.
Menus são os mesmos da máquina Edit mais os menus de usuários e administrativos.
Com direitos de hacker o usuário poderá usar a Máquina Hack.
Apresenta interfaces para o desenvolvimento de plugins, acesso ao Catalyst: hooks e helpers. Objetiva o design e construção da arquitetura do CMS como criar widgets, desenvolver novas funcionalidades ou uma nova extensão.
Uma idéia interessante é desenvolver interface para servidores de versionamento, como git, svn e cvs.
O acesso ao conteúdo. A única coisa sem a qual o YAC não existe.
Voce certamente vai criar stacks sensacionais!!
Os stacks especiais implementados no core do YAC: Content, Control e Widget.
O gerenciador de menus. Tem mais 2 métodos: url e name
Conteúdo em html.
Conteúdo em javascript.
Classe de autenticação. Trata usuários, regras e direitos.
Classe que representa o usuário.
Objetos Layout são templates do view TT, do Catalyst, armazenados em banco de dados.
Extensões são classes do Moose.
Aos amigos do do SP-pm, Rio-pm e Cascavel-pm pelo incentivo. Obrigado!
LCopyright 2010 Monsenhor (Ricardo Filipo).
This program is free software; you can redistribute it and/or modify it under the terms of either: the GNU General Public License as published by the Free Software Foundation; or the Artistic License.
See http://dev.perl.org/licenses/ for more information.