Esta decidido, vamos estudar Ruby! Motivo? Por essa Linguagem de Programação se mostrar cada vez mais promissora.

Tanto pela comunidade de apaixonados e ótimos Developers, Programmers ou o que preferirem intitular. Quanto pelo fato de Ruby, na sua essência, não se deixar cair na burocracia, verbosidade, Whatever dentre outras características chatas que encontramos em algumas linguagens, digamos, Não Tão Pragmáticas.

Sendo assim, antes de vislumbrarmos essa poderosa linguagem precisaremos preparar a nossa mesa de trabalho! Para logo após, iniciar as nossas atividades de: Expressar Modelos de Negócio, Expressões Matemáticas e todo Aparato Tecnológico que dispomos, em belos Algoritmos Computacionais escritos em Ruby.

Então vamos ao tema de hoje Preparando meu Ambiente de Desenvolvimento Ruby no Linux Ubuntu.

Cenário

Sistema Operacional: Ubuntu
Dependências: Zsh, Ruby, Git, SQLite, gEdit, Firefox

Problema

Acho que o único problema aqui será se você vier do mundinho Windows. Pois se já estiver acostumado com o mundo fértil e vasto do Tux ou da Maçã não teremos problema algum.

Isso acontece pois o Ruby foi concebido para funcionar plenamente sob uma plataforma Unix Like. Então um conhecimento básico de C e Unix Shell, são mais do que bem vindos.

Logo para usuários de Windows esse artigo pode causar um certo desconforto Mas siga em frente, e quebre esse Paradigma.

Solução

Para darmos uma dinâmica nesse artigo, você poderá executar esse passo-a-passo agora mesmo. Sem precisar se preocupar em particionar seu querido HD. Utilizando a maravilhosa alternativa chamada Virtualização, assim deixo uma listagem de alguns Softwares que podemos adotar.

• VirtualBox
• VMware (eu utilizo esse daqui)
• Parallels
• Virtual PC

O processo de instalação desses softwares são bem simples, mas em caso de dúvida, nada como uma rápida consulta no respectivo manual para clarear nossas idéias.

Sistema Operacional

Como dito inicialmente utilizaremos Linux, sendo que a versão adotada nesse artigo será a Ubuntu 10.04, em sua versão Desktop.

Nosso primeiro passo será baixar a Imagem ISO no link abaixo.

• Download Ubuntu Desktop Edition (32-bit)

Depois de alguns Cafés teremos baixada a Imagem ISO.

Agora efetuaremos a instalação padrão, sem se preocupar com detalhes de configurações adicionais. Isso não será necessário! E se você não esta acostumado a instalar uma Distribuição Linux, você ficará surpreso com o rápido e prático processo de configuração no Ubuntu.

Veja exemplo abaixo.

• Installing Ubuntu 10.04 LTS

Finalizado o processo de instalação, inicie o Terminal do Ubuntu, para certificar que esta tudo em dia:

# Nele digite os comandos
sudo apt-get update
sudo apt-get upgrade

Agora sim mandaremos brasa

Agilidade nesse artigo. O tempo urge!

Algumas Dependências

No Terminal instalaremos alguns pacotes, precisos para a base, do nosso ambiente de desenvolvimento.

# Nele digite os comandos
sudo apt-get install build-essential zlib1g-dev libssl-dev libreadline5-dev checkinstall default-jdk curl

Shell

Se você vai programar no Linux aprenda a gostar do Terminal, ele será seu melhor amigo.

E alguns acessórios legais para o Terminal, são: o zsh para uma maior interatividade do que o clássico bash e o oh-my-zsh para gerenciar a configuração do zsh. Então vamos lá!

# Instalar o zsh
sudo apt-get install zsh zsh-dev

# Instalar o oh-my-zsh
cd ~ && wget http://github.com/robbyrussell/oh-my-zsh/raw/master/tools/install.sh -O - | sh

Algumas dicas:

• Digite zsh no Terminal para habilitar o Z Shell
• Como utilizaremos Ruby em nosso ambiente, habilite o Plugin para essa linguagem, no arquivo ~./zshrc, de plugins=(git) para plugins=(git ruby)
• Se a instalação gerar o diretório .git/ basta excluí-lo via comando rm -rf ~/.git/

Sistema de Controle de Versão

Se vamos programar em Ruby é bom saber que o SCM Git é o mais utilizado pela galera. E se você tiver alguma dúvida se vale a pena utilizá-lo, assista essa Tech Talk com o Linus Torvalds falando sobre o Git.

De toda forma daremos continuidade ao artigo. Agora vamos lá!

# Instalar o Git
sudo apt-get install git-core

# Instalar também uma interface gráfica para o Git
sudo apt-get install gitg

Algumas dicas:

• GitG será interessante para navegar com mais facilidade pela arvore de histórico dos nossos commits
• Como também alguns sites para aprender a utilizar esse SCM, como GitCasts, Git Ready, Pro Git e Git User’s Manual

são uma boa leitura

Banco de Dados SQL

Já fazem alguns meses que utilizo o SQL Database chamado SQLite que resumidamente:

É uma biblioteca em linguagem C que implementa um banco de dados SQL embutido.

Que tem como características:

É Software Livre/domínio público e Multiplataforma; É um mecanismo de armazenamento seguro com transações ACID; Implementa a maioria do SQL92; Permite guardar o banco de dados em um único arquivo; Suporta bases de dados acima de 2 terabytes.

Sem falar que empresas como Bloomberg, Symbian, Mozilla e Adobe patrocinam o desenvolvimento desse SQL Database.

De toda forma, vamos lá!

# Instalar o SQLite
sudo apt-get install sqlite3 libsqlite3-dev

# Instalar também uma interface gráfica para o SQLite
sudo apt-get install sqlitebrowser

Ruby

E que rufem os tambores… Senhoras e Senhores, com vocês, a maneira mais rápida de habilitar, nada mais nada menos do que: Ruby Enterprise Edition! Em nosso ambiente de desenvolvimento.

# Baixar o Ruby Enterprise Edition 1.8.7
cd ~ && wget http://rubyforge.org/frs/download.php/71100/ruby-enterprise_1.8.7-2010.02_i386_ubuntu10.04.deb

# Instalar o Ruby
sudo dpkg -i ruby-enterprise_1.8.7-2010.02_i386_ubuntu10.04.deb

# Adicionar um repositório secundário de RubyGems
gem sources -a http://gems.github.com

# E checar nossa instalação
ruby -v

Editor de Texto

E que IDE utilizaremos para editar o nosso código Ruby? A resposta é simples: Nenhuma!

Não precisamos de nenhum “trator” para codificar. Precisamos sim de um funcional editor de texto e o que gosto de utilizar no Linux é o gEdit.

Tudo bem. Eu sei. A galera no Linux gosta de usar o Vi ou Vim como editor de texto. Mas ainda não me acostumei com esse “tiozinho”. Então vamos de gEdit!

Para darmos um plus plus no gEdit, adicionaremos o Plugin chamado gMate que adiciona diversas melhorias ao gEdit, tornando-o um pouco semelhante ao aclamado Textmate do MacOSX.

E assim ganhamos funcionalidades tais como:

• Advanced Bookmarks. Highlight, remenber and toggle bookmarks in your files
• Classbrowser. A Classbrowser (depends of ctags, I use exuberant-ctags)
• Find in Files. Find a string in files (integrated with filebrowser)
• Gedit Open File. Regex based file open (like textmate Go to file…)
• Gedit Todo. Find Todo Marks in source files (integrated with filebrowser)
• Gemini. Pair complete for quotes and braces
• Quickhighligthmode. Fast change current highlight mode
• Rails Extract Partial. Extract selected region of rhtml as a partial
• Rails Hotcommands. Execute Rails Commands (such rake tasks)
• Rails Hotkeys. Navigation in Rails Project Files
• Regex Search Replace. Search and replace with regular expressions
• Smart Indent. Smart Indentation regex based
• Tabulation. Auto set tabs and spaces based on file type
• Text Tools. Some text manipulation improvements (adapted from line tools)
• Trailsave. Remove trailing spaces before save a document
• Word Completion. Word completion plugin
• Gedit Go To File. Yet Another Go to File plugin Just Like SnapOpen and GeditOpenFiles also based in Textmate Go to file
• Multi Edit. Check it out at author’s page http://jon-walsh.com/journal/multi-edit
• Pastie. Paste a selection of code or a source file to pastie.org directly from editor http://github.com/ivyl/gedit-pastie
• Zen Coding. Tools for faster HTML/CSS coding http://github.com/mikecrittenden/zen-coding-gedit

Vamos a instalação!

# Adicionar o Ubuntu on Rails PPA
sudo apt-add-repository ppa:ubuntu-on-rails/ppa

# Instalar o gMate
sudo apt-get install gedit-gmate

Agora vamos as dicas:

• Após inicializar o gEdit vá no menu Editar > Preferências e configure o gEdit ao seu modo
• Particularmente costumo habilitar todos os Plugins, utilizar o esquema de cor Ruby Blue e habilitar a numeração de linhas

Navegador Padrão

Tenho que dizer que não utilizo esse navegador somente no Linux, quando o foco é desenvolvimento. Utilizo ele também no MacOSX. E em último caso, quando (extremamente) preciso, no Windows também .

Pois basicamente o Firefox é o melhor navegador para desenvolvimento de aplicações Web, na minha humilde opnião é claro, isso graças a diversos Plugins muito bem escritos, que dão um ótimo valor a esse navegador de Internet.

Assim a seguir deixo o link dos Plugins que utilizo:

• Delicious Bookmarks, para manter os Favoritos em dia
• Firebug, como uma excelente extensão do nosso editor de texto
• Gears, como o HTML5 ainda não se tornou o padrão adotado pelos navegadores de Internet, esse rapaz chamado Gears do Google traz algumas funcionalidades de Cache, Database e Pool para o lado cliente da nossa aplicação Web. Que merece seu estudo a parte
• JSONView, para visualizar estruturas JSON de forma mais adequada
• Page Speed, para testar a performance da nossa aplicação
• RESTClient, que é uma boa ferramenta para testar serviços REST
• Selenium IDE, para criar testes nas Views
• YSlow, para também testar a performance da nossa aplicação

Ferramentas Online

Antes de chegarmos ao final desse artigo. É bom comentar sobre algumas aplicações Web, que são úteis quando alguém do time esta a maior parte do tempo remoto (mas não necessariamente). Então vamos lá!

• Dimdim, para Web Conferencing
• Github, para Social Code
• Pivotal, para Trac
• Skype, para Free Call
• Wave, para Brainstorming

A parte do não necessariamente, se refere ao GitHub por ser um maravilhoso misto de Hospedagem de Projetos + Rede Social.

Hospedagem de Projetos pois muitas das RubyGems e Plugins e Whatever que a galera do Ruby utiliza, constam nesse local.

Rede Social pois além de estar na moda Brincadeiras a parte, você poderá ter uma forma de contato direto com esses Developers que commitam no GitHub. E etc…

Material de Estudo

Não posso deixar vocês sem mais alguns Links, esses dessa vez, sobre material de estudo para Ruby.

• Learn To Program
• Ruby in Twenty Minutes
• Ruby Essentials
• Programming Ruby
• Ruby User’s Guide
• Ruby Programming
• Ruby Doc

E material de estudo para Rails. Pois se tornou normal para os Web Developers chegarem ao mundo Ruby, através desse excelente Framework Web.

Porém não fique somente no que o Rails propõem, pois Rails é basicamente a adoção do que existe de boas práticas em Web Development e Ruby.

• Ruby on Rails Guides
• Desenvolvimento Ágil para Web 2.0 com Ruby on Rails

Bom é isso caro leitor.

Quem escreveu foi o André Moreira.
Obrigado pela visita e até o próximo post.

Oh não, Jason… Corra!!!

Jason Voorhees, sobrou para você o trocadilho inicial desse artigo sobre como consumir JSON via jQuery.

É claro, caso você tenha interesse, não deixe de escutar esse Podcast sobre a consagrada Franquia de Terror – Sexta-feira 13.

Agora retornamos a nossa programação!

Cenário

Sistema Operacional: Mac OSX
Dependências: Ruby, Rails, WillPaginate, jQuery

Problema

Você gosta de fazer a mesma coisa sempre? (Eu não) Por quê? (Isso não é divertido) Mas por quê? (Porque demanda um certo desperdício de tempo) Ah tudo bem!

.

Então, da mesma forma que tento evitar essa repetição que acaba em sono e acabará realmente. Vide exemplo ao lado.

.

Sua pessoa não quer ver o seu predileto Browser de Internet, lotado de Add-ons, recarregar uma pagina por completo. Quando o necessário é apenas atualizar uma pequenina parte do conteúdo dela.

O caso de uso

Vamos lá! Costumamos popular uma Table, através do ERb, codificado no exemplo abaixo:

<!-- Parte do arquivo -->
<table>

	<tr>
		<th>Description</th>
	</tr>

	<% @reminders.each do |reminder| %>
		<tr>
			<td><%=h reminder.description %></td>
			<td><%= link_to 'Show', reminder %></td>
			<td><%= link_to 'Edit', edit_reminder_path(reminder) %></td>
			<td><%= link_to 'Destroy', reminder, :confirm => 'Are you sure?', :method => :delete %></td>
		</tr>
	<% end %>

</table>

<br />
<%= will_paginate @reminders %>

Algo bem básico, que aprendemos em cursos “Something for Dummies” Nada fora do comum.

Mas agora. Como fazer para que somente a nossa tabela HTML sofra atualização de conteúdo? Via JSON? E o restante fique quietinho, ali na dele.

Solução

Usar o The Write Less, Do More do jovem John Resig, para consumir o JavaScript Object Notation, do conhecido Douglas Crockford. E para expor esse JSON, usaremos o Rails com uma pequena ajuda do WillPaginate.

A aplicação Rails

Command+Space e dá-lhe Terminal no Spotlight.

# Criar o projeto Rails
cd ~/Documents/workspace-ruby && rails todo && cd todo

# Se você ainda não tiver a RubyGem NiftyGenerators
sudo gem install nifty-generators

# Definir o que nossa aplicação terá
script/generate nifty_scaffold reminder description:string
script/generate nifty_layout

# E finalmente criar o database
rake db:create && rake db:migrate && mate .

Agora no Textmate pressionar Command+t, procurar o arquivo environment.rb, para adicionar a RubyGem do WillPaginate.

# Parte do arquivo
Rails::Initializer.run do |config|
	config.gem "will_paginate"
end

Feito isso, no Terminal vamos certificar que essa RubyGem esta disponível.

sudo rake gems:install

No Textmate pressionar Command+t, procurar o arquivo reminders_controller.rb, para ativar o WillPaginate no Controller.

# Parte do arquivo
class RemindersController < ApplicationController
	def index
		@reminders = Reminder.paginate :page => params[:page], :per_page => 100
	end
end

Ainda no Textmate pressionar Command+t, procurar o arquivo index.html.erb, para ativar o WillPaginate na View. Temporariamente é claro, o objetivo aqui é justamente não utilizar o suporte do WillPaginate na View, apenas no Controller será o suficiente.

<% title "Reminders" %>

<table>

	<tr>
		<th>Description</th>
	</tr>

	<% for reminder in @reminders %>
		<tr>
			<td><%=h reminder.description %></td>
			<td><%= link_to "Show", reminder %></td>
			<td><%= link_to "Edit", edit_reminder_path(reminder) %></td>
			<td><%= link_to "Destroy", reminder, :confirm => 'Are you sure?', :method => :delete %></td>
		</tr>
	<% end %>

</table>

<!-- Inserir esse bloco -->
<br />
<%= will_paginate @reminders %>
<!-- Inserir esse bloco -->

<p><%= link_to "New Reminder", new_reminder_path %></p>

E precisamos também popular o nosso database. Uma forma legal de fazer essa geração, dos dados de mentirinha , é com a RubyGem Faker. Super prática e com uma API de fácil fluência.

# Se você ainda não tiver a RubyGem Faker
sudo gem install faker

# Digitar no Terminal
script/console

# Legal (!) IRB com gostinho de Rails
require 'faker'
1000.times { Reminder.create!(:description => Faker::Name.name) }
exit

# E para completar start a aplicação
script/server

Ah! Nota, no próprio Terminal abra o seu Browser padrão através da dica abaixo.

# Command+t para ter uma novíssima aba
open http://localhost:3000/reminders

E assim temos nossa tabela paginando da forma mais simples possível.

Refatorar a aplicação: Adicionar jQuery

Por padrão o Rails vem com as bibliotecas de JavaScript do PrototypeJS, porém as bibliotecas que utilizaremos nesse artigo, serão do jQuery.

Um dos motivos é claro, estou com vários livros aqui em casa sobre o jQuery:

• jQuery – Visual QuickStart Guide
• jQuery Cookbook – Solutions & Examples for jQuery Developers
• jQuery in Action – Second Edition
• jQuery Recipes – A Problem Solution Approach
• Learning jQuery 1.3

Então preciso praticar meus estudos em alguns “Casos de Uso”. Ah! E depois publicar no meu Blog Não tem graça reter conhecimento.

Assim chega de papo, é hora de pegar essas dependências do jQuery na Web. E faremos isso de uma maneira muito simples, pois utilizaremos um Plug-in no estilo Grid chamado DataTables que já vem com tudo o que precisamos. Então volte ao Terminal.

# Baixar o Plug-in DataTables no diretório Downloads do usuário
cd ~/Downloads && wget http://www.datatables.net/releases/dataTables-1.6.2.zip && tar -zvxf dataTables-1.6.2.zip && rm dataTables-1.6.2.zip

# Mover os arquivos para o projeto Rails
cp dataTables-1.6/media/css/*.* ~/Documents/workspace-ruby/todo/public/stylesheets
cp dataTables-1.6/media/images/*.* ~/Documents/workspace-ruby/todo/public/images
cp dataTables-1.6/media/js/*.* ~/Documents/workspace-ruby/todo/public/javascripts

Legal, podemos voltar para o Textmate agora e codificar mais um pouco. Então no Textmate pressionar Command+t, procurar o arquivo application.html.erb, para adicionar um novo bloco Yield no View. Nosso arquivo deve ficar conforme abaixo:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">

	<head>
		<title><%= h(yield(:title) || "Untitled") %></title>
		<%= stylesheet_link_tag 'application' %>
		<%= yield(:head) %>
	</head>

	<body>
		<div id="container">
			<%- flash.each do |name, msg| -%>
				<%= content_tag :div, msg, :id => "flash_#{name}" %>
			<%- end -%>

			<%- if show_title? -%>
				<h1><%=h yield(:title) %></h1>
			<%- end -%>

			<%= yield %>

			<!-- Inserir esse bloco -->
				<%= yield(:javascript_end_of_the_body) %>
			<!-- Inserir esse bloco -->
			</div>
	</body>

</html>

Ainda no Textmate pressionar Command+t, procurar o arquivo index.html.erb, para adicionar as dependências do jQuery no View. Além de remover aquela tabela feia daqui, no lugar deixando uma bela DIV. Nosso arquivo deve ficar conforme abaixo:

<% content_for :head do %>
	<%= stylesheet_link_tag 'demo_table_jui' %>
<% end %>

<% title "Reminders" %>

<div id="myTable"></div>

<p><%= link_to "New Reminder", new_reminder_path %></p>

<% content_for :javascript_end_of_the_body do %>
	<script type="text/javascript">
		var authenticity_token = '<%= form_authenticity_token %>';
	</script>
	<%= javascript_include_tag 'jquery' %>
	<%= javascript_include_tag 'jquery.dataTables' %>
	<%= javascript_include_tag 'views.registros.index' %>
<% end %>

Hummm, algo interessante de comentar aqui, é a utilização do código JavaScript no final do Body. Isso faz com que o carregamento da página seja muito mais rápido.

Pois quer você queira ou não, bibliotecas como PrototypeJS e jQuery tem uma boa quantidade de código. Que se você deixar pra carregar no Head, você terá um pequeno problema de performance no carregamento dela.

Não é à toa que a turma Developers do Yahoo, indica a prática descrita anteriormente, como uma boa opção de uso. E os Engineers do Google, colaboram com a dica de permanecer com CSS no topo. Viu!

Rapidamente criaremos um arquivo JavaScript que utilizaremos mais a frente. Volte ao Terminal.

cd ~/Documents/workspace-ruby/todo && touch public/javascripts/views.registros.index.js

Refatorar a aplicação: Expor JSON

No Textmate pressionar Command+t, procurar o arquivo reminders_controller.rb. Aqui faremos uma pequena adição de código, pois precisamos fazer com que o Rails retorne não somente uma rota HTML mas como também uma novíssima rota JSON. Porém deixando apenas para a rota JSON a funcionalidade de retornar dados do nosso Model. Nosso arquivo deve ficar conforme abaixo:

# Parte do arquivo
class RemindersController < ApplicationController
	def index
		respond_to do |wants|
			wants.html
			wants.json { render :json => Reminder.paginate(:page => params[:page], :per_page => 100) }
		end
	end
end

Se fizermos um pequeno teste agora, veremos que já é possível consumir esse JSON via Terminal. Usando a biblioteca cURL, muito conhecida no mundo Unix:

curl http://localhost:3000/reminders.json

Teremos um retorno semelhante ao descrito a seguir:

# Parte do arquivo
[{"reminder":{"created_at":"2010-05-23T20:15:24Z","updated_at":"2010-05-23T20:15:24Z","id":1,"description":"Something write in... Sun May 23 17:15:24 -0300 2010"}},{"reminder":{"created_at":"2010-05-23T20:15:24Z","updated_at":"2010-05-23T20:15:24Z","id":2,"description":"Something write in... Sun May 23 17:15:24 -0300 2010"}},{"reminder":{"created_at":"2010-05-23T20:15:24Z","updated_at":"2010-05-23T20:15:24Z","id":3,"description":"Something write in... Sun May 23 17:15:24 -0300 2010"}},{"reminder":{"created_at":"2010-05-23T20:15:24Z","updated_at":"2010-05-23T20:15:24Z","id":4,"description":"Something write in... Sun May 23 17:15:24 -0300 2010"}},{"reminder":{"created_at":"2010-05-23T20:15:24Z","updated_at":"2010-05-23T20:15:24Z","id":5,"description":"Something write in... Sun May 23 17:15:24 -0300 2010"}},{"reminder":{"created_at":"2010-05-23T20:15:24Z","updated_at":"2010-05-23T20:15:24Z","id":6,"description":"Something write in... Sun May 23 17:15:24 -0300 2010"}},{"reminder":{"created_at":"2010-05-23T20:15:24Z","updated_at":"2010-05-23T20:15:24Z","id":7,"description":"Something write in... Sun May 23 17:15:24 -0300 2010"}},{"reminder":{"created_at":"2010-05-23T20:15:24Z","updated_at":"2010-05-23T20:15:24Z","id":8,"description":"Something write in... Sun May 23 17:15:24 -0300 2010"}},{"reminder":{"created_at":"2010-05-23T20:15:24Z","updated_at":"2010-05-23T20:15:24Z","id":9,"description":"Something write in... Sun May 23 17:15:24 -0300 2010"}},{"reminder":{"created_at":"2010-05-23T20:15:24Z","updated_at":"2010-05-23T20:15:24Z","id":10,"description":"Something write in... Sun May 23 17:15:24 -0300 2010"}}]

É um retorno bem comprimido, sem Syntaxhighlighter e Indentação. Cru!

Agora veremos esse mesmo código só que no velho guerreiro Firefox, utilizando o Add-on JSONView do Geek Ben Hollis.

Observação, recentemente testei esse mesmo Add-on no Chrome e ele também funciona perfeitamente.

Refatorar a aplicação: Consumir JSON

Ufa, finalmente! Chegamos ao momento de codificar em JavaScript. No Textmate pressionar Command+t, procurar aquele arquivo views.registros.index.js. Ele deve ficar conforme abaixo:

$(function(){
	const PLACE = '#myTable',

	RESOURCE = '/reminders.json?page=',

	PER_PAGE = 100;

	var object = {
		'aaData':[],
		'aoColumns':[{'sTitle':'Created At'}, {'sTitle':'Description'}, {'sTitle':'Action'}],
		'bJQueryUI':true,
		'bPaginate':false,
		'bLengthChange':false,
		'bFilter':true,
		'bSort':false,
		'bInfo':false,
		'bAutoWidth':false
	},

	page = 1;

	$.fn.dataTableJSON = function(){
		$(PLACE).ajaxSend(function(){
			$(this).text('Loading...');
		});

		$.getJSON(RESOURCE + page, function(data){
			$.fn.resourceConsuming(data);
			$.fn.reloadTable();
			$.fn.pagination();
		});
	};
	$.fn.dataTableJSON();

	$.fn.resourceConsuming = function(data){
		object['aaData'] = [];

		$.each(data, function(key, value){
			object['aaData'].push([
				value['reminder']['created_at'].slice(0, 10) +
				' - ' +
				value['reminder']['created_at'].slice(11, 19),

				'<a href="/reminders/' + value['reminder']['id'] + '">' + value['reminder']['description'] + '</a>',

				'<a href="/reminders/' + value['reminder']['id'] + '/edit">Edit</a>' +
				' || ' +
				'<a onclick="if (confirm(\'Are you sure?\')) { var f = document.createElement(\'form\'); f.style.display = \'none\'; this.parentNode.appendChild(f); f.method = \'POST\'; f.action = this.href;var m = document.createElement(\'input\'); m.setAttribute(\'type\', \'hidden\'); m.setAttribute(\'name\', \'_method\'); m.setAttribute(\'value\', \'delete\'); f.appendChild(m);var s = document.createElement(\'input\'); s.setAttribute(\'type\', \'hidden\'); s.setAttribute(\'name\', \'authenticity_token\'); s.setAttribute(\'value\', \'' + authenticity_token + '\'); f.appendChild(s);f.submit(); };return false;" href="/reminders/' + value['reminder']['id'] + '">Destroy</a>'
			]);
		});
	};

	$.fn.reloadTable = function() {
		$(PLACE).html('');

		$(PLACE)
			.append('<br />')
			.append('<table cellpadding="0" cellspacing="0" border="0" class="display" id="dataTableJSON"></table>')
			.append('<br />');

		$('#dataTableJSON').dataTable(object);
	};

	$.fn.pagination = function(){
		$(PLACE)
			.append('<div id="dataTableJSON_paginate" class="dataTables_paginate paging_two_button"><div id="dataTableJSON_previous" title="Previous" class="paginate_disabled_previous"></div><div id="dataTableJSON_next" title="Next" class="paginate_disabled_next"></div></div>')
			.append('<p>&nbsp;</p>');

		(page === 1) ? $('#dataTableJSON_previous').hide() : $.fn.previousPage();

		(object['aaData'].length < PER_PAGE) ? $.fn.lastPage() : $.fn.nextPage();
	};

	$.fn.previousPage = function(){
		$('#dataTableJSON_previous').click(function(){
			$(this).hide();
			$('#dataTableJSON_next').hide();
			--page;
			$.fn.dataTableJSON();
		});
	};

	$.fn.nextPage = function(){
		$('#dataTableJSON_next').click(function(){
			$(this).hide();
			$('#dataTableJSON_previous').hide();
			++page;
			$.fn.dataTableJSON();
		});
	};

	$.fn.lastPage = function(){
		$('#dataTableJSON_next').hide();
		if (object['aaData'].length === 0) { --page; $.fn.dataTableJSON(); }
	};
});

E eu sei, código JavaScript com jQuery fica bonito como açúcar. Mas prefiro explicar rapidamente cada parte, do código anterior e assim deixar mais alguns links do jQuery só que dessa vez da API dele.

No arquivo views.registros.index.js, é executado o Helper chamado form_authenticity_token do Rails. Sem ele nós receberíamos o erro ActionController::InvalidAuthenticityToken.

<!-- Parte do arquivo -->
<script type="text/javascript">
	var authenticity_token = '<%= form_authenticity_token %>';
</script>

No arquivo index.html.erb, respeitamos a boa prática de não anteceder/declarar const ou var para tudo quanto é objeto/variável JavaScript. E como também tento deixar o mais visivelmente, dentro do possível, as variáveis que devemos “setar” para essa nossa aplicação funcionar.

// Parte do arquivo
// Definimos o atributo ID que devemos pegar daquela DIV do arquivo index.html.erb
const PLACE = '#myTable',

// Definimos o Location do nosso recurso JSON
RESOURCE = '/reminders.json?page=',

// Definimos quantos registros serão retornados por pagina
PER_PAGE = 100;

// Definimos o objeto que populará o nosso Plug-in DataTables
var object = {
	'aaData':[],
	'aoColumns':[{'sTitle':'Created At'}, {'sTitle':'Description'}, {'sTitle':'Action'}],
	'bJQueryUI':true,
	'bPaginate':false,
	'bLengthChange':false,
	'bFilter':true,
	'bSort':false,
	'bInfo':false,
	'bAutoWidth':false
},

// E ufa definimos também em que pé a nossa paginação inicializará
page = 1;

Feito isso, o próximo passo foi definir algo que podemos “denominar de construtor” do nosso código JavaScript. Mas isso não é um construtor, tudo bem. Assim logo de cara nos deparamos com duas características do jQuery:

• Plugins/Authoring
• .ajaxSend()
• jQuery.getJSON()

// Parte do arquivo
// Então definimos nosso construtor de mentirinha
$.fn.dataTableJSON = function(){

	// Adicionamos uma pequena mensagem enquanto o JSON é carregado
	$(PLACE).ajaxSend(function(){
		$(this).text('Loading...');
	});

	// Que chama o nosso recurso JSON
	$.getJSON(RESOURCE + page, function(data){

		// Depois consome ele
		$.fn.resourceConsuming(data);

		// Daí ele constrói a nossa tabela
		$.fn.reloadTable();

		// E paginamos tudo
		// É paginamos, isso mesmo, nada de usar o Helper do WillPaginate aqui na View
		$.fn.pagination();
	});

};

// E finalmente executamos tudo isso. Ufa!
$.fn.dataTableJSON();

Mas tudo isso, o quê? Como disse vamos por partes! Aqui brincaremos com Array do JavaScript e com uma característica de Loop muito bonita do jQuery:

• jQuery.each()

// Parte do arquivo
$.fn.resourceConsuming = function(data){
	object['aaData'] = [];

	// Isso daqui é um Loop
	// Um bonito Loop que para Each item, criamos uma Function key/value
	// Que consome o nosso JSON adicionando-o naquela variável object
	$.each(data, function(key, value){
		object['aaData'].push([

			// Até aqui nada demais
			// Brincamos com o método Slice, para formatar a data
			value['reminder']['created_at'].slice(0, 10) +
			' - ' +
			value['reminder']['created_at'].slice(11, 19),

			// Aqui adicionamos um link, nada demais
			'<a href="/reminders/' + value['reminder']['id'] + '">' + value['reminder']['description'] + '</a>',

			// Outro link, nada demais
			'<a href="/reminders/' + value['reminder']['id'] + '/edit">Edit</a>' +
			' || ' +

			// Essa parte é muito importante
			// Basicamente um Command+c e Command+v do Helper link_to
			// Que recebe, aquele, authenticity_token
			'<a onclick="if (confirm(\'Are you sure?\')) { var f = document.createElement(\'form\'); f.style.display = \'none\'; this.parentNode.appendChild(f); f.method = \'POST\'; f.action = this.href;var m = document.createElement(\'input\'); m.setAttribute(\'type\', \'hidden\'); m.setAttribute(\'name\', \'_method\'); m.setAttribute(\'value\', \'delete\'); f.appendChild(m);var s = document.createElement(\'input\'); s.setAttribute(\'type\', \'hidden\'); s.setAttribute(\'name\', \'authenticity_token\'); s.setAttribute(\'value\', \'' + authenticity_token + '\'); f.appendChild(s);f.submit(); };return false;" href="/reminders/' + value['reminder']['id'] + '">Destroy</a>'
		]);
	});

};

Avançando rapidamente chegamos a parte em que passamos o Object para a Table, usando também as facilidades que o jQuery oferece.

• .html()
• .append()
• .dataTable(), mas esse daqui é uma funcionalidade do Plug-in já citado DataTables

// Parte do arquivo
$.fn.reloadTable = function() {

	// Limpamos o conteudo do nosso PLACE
	$(PLACE).html('');

	// Adicionanamos um novo conteúdo
	$(PLACE)
		.append('<br />')
		.append('<table cellpadding="0" cellspacing="0" border="0" class="display" id="dataTableJSON"></table>')
		.append('<br />');

	// E chamamos o dataTable
	$('#dataTableJSON').dataTable(object);
};

O restante do código é toda a parte de paginação do nosso Grid, nada demais.

// Parte do arquivo
$.fn.pagination = function(){
	$(PLACE)
		.append('<div id="dataTableJSON_paginate" class="dataTables_paginate paging_two_button"><div id="dataTableJSON_previous" title="Previous" class="paginate_disabled_previous"></div><div id="dataTableJSON_next" title="Next" class="paginate_disabled_next"></div></div>')
		.append('<p>&nbsp;</p>');

	(page === 1) ? $('#dataTableJSON_previous').hide() : $.fn.previousPage();

	(object['aaData'].length < PER_PAGE) ? $.fn.lastPage() : $.fn.nextPage();
};

$.fn.previousPage = function(){
	$('#dataTableJSON_previous').click(function(){
		$(this).hide();
		$('#dataTableJSON_next').hide();
		--page;
		$.fn.dataTableJSON();
	});
};

$.fn.nextPage = function(){
	$('#dataTableJSON_next').click(function(){
		$(this).hide();
		$('#dataTableJSON_previous').hide();
		++page;
		$.fn.dataTableJSON();
	});
};

$.fn.lastPage = function(){
	$('#dataTableJSON_next').hide();
	if (object['aaData'].length === 0) { --page; $.fn.dataTableJSON(); }
};

.

Viu!

Não foi tão doloroso assim, escrever um pouco de código JavaScript.

.

.

Bom é isso caro leitor.

Quem escreveu foi o André Moreira.
Obrigado pela visita e até o próximo post.

Há algum tempo que pratico o Deploy das minhas aplicações JRubyOnRails, no Apache Tomcat.

Esse que pode ser recomendado para utilização em sistemas, digamos: Singelo. Pois até hoje não vi o Servidor Tomcat, se sair bem quando a questão é desempenho.

Assim, para #App’s básicas, vou demonstrar como realizar esse processo de publicação em Produção. Que convenhamos, é simples de ser efetuado.

Cenário

Sistema Operacional: Mac OSX
Dependências: Apache Tomcat, Git, JRuby, Warbler

Problema

Pronto! Desenvolvi e Testei tim-tim por tim-tim, todas as partes da minha aplicação, com o bendito do servidor-zinho Mongrel abaixo:

jruby -S script/server

Isso para tornar mais pratico, o desenvolvimento. Mas agora, como coloco meu projeto em Ambiente de Produção? Devo fazer isso também?

jruby -S script/server -e production

Se a aplicação servir pouquíssimas pessoas (ex. 40), é… Não vejo problema. Mas existem outras maneiras e uma delas é a descrita a seguir.

Solução

O Terminal é seu amigo, repita isso comigo! Senão, vá para o mundo Windows

Preparando o ambiente

Via linha de comando, execute os seguintes passos:

# Baixar o Tomcat no diretório Home do usuário
cd ~ && wget http://ftp.unicamp.br/pub/apache/tomcat/tomcat-6/v6.0.26/bin/apache-tomcat-6.0.26.tar.gz

# Descompactar o arquivo TAR.GZ e descartar o arquivo compactado
tar -zvxf apache-tomcat-6.0.26.tar.gz && rm apache-tomcat-6.0.26.tar.gz

# Testar a instalação
cd apache-tomcat-6.0.26 && java -Xmx512m -Xms512m -XX:PermSize=256m -jar bin/bootstrap.jar

# A última linha deve conter algo como
INFO: Server startup in 1451 ms

Resumindo, já temos um Servidor Web funcional. Para maiores detalhes sobre administração do Apache Tomcat, vale conversar com um SysAdmin!

Eis um Rouxinol chamado Warbler

Agora vamos usar uma RubyGem muito eficiente, isso mesmo o Warbler, para fazer com que o nosso projeto JRubyOnRails, funcione no Apache Tomcat. Seja adicionando o pacote WAR no diretório “webapps” ou simplesmente direcionando ao diretório no qual foi “explodido” o nosso pacote WAR Buuum!!!

Ah! Uma pequenina observação:

Sobre o projeto vamos utilizar o meu Sistema de Registro (beta), como exemplo. Assim aproveito para fazer aquela propaganda

Vá para o Terminal!

# Parar aquele processo do Tomcat
# Teclar Control+C

# Voltar para o Home do usuário e baixar o Projeto via Git
cd .. && git clone git://github.com/mourdok/registro.git && cd registro

# Apagar os seguintes arquivos e diretórios (Motivo? Fins didáticos!)
rm -rf vendor/plugins/warbler/ && rm config/warble.rb

# Instalar a RubyGem Warbler
sudo jruby -S gem install warbler

# Adicionar o Warbler ao projeto
jruby -S warble pluginize

# Gerar o arquivo de configuração warble.rb
jruby -S script/generate warble

Eis uma rápida pausa nas linhas de comando, para explicar o que devemos fazer, com esse arquivo de configuração.

Se formos reparar. Por padrão esse “script/generate” não habilita algumas configurações que necessitaremos. Configurações essas que se forem deixadas no esquecimento. Com certeza, nossa aplicação não funcionará.

Então vamos modificar passo-a-passo, esse arquivo.

Vá para o Terminal!

# Através do seu editor preferido, no meu caso TextMate (mate)
# Edite o seguinte arquivo
mate config/warble.rb

Agora fora do Terminal, faremos tais modificações.

Code in JRuby! Yes, I am a happy programmer!

No Editor!

# Abaixo do último comentário, iniciado por "Additional files/directories to include, above those in config.dirs", adicione a linha
config.includes = FileList["db/*"]

# Abaixo do comentário, iniciado por "You can also use regexps or Gem::Dependency objects for flexibility or", adicione as linhas
config.gems << Gem::Dependency.new("rack")
config.gems << Gem::Dependency.new("jruby-openssl")
config.gems << Gem::Dependency.new("activerecord-jdbcsqlite3-adapter")

# Abaixo do comentário, iniciado por "Value of RAILS_ENV for the webapp -- default as shown below", adicione a linha
config.webxml.rails.env = 'production'

# Abaixo do comentário, iniciado por "Application booter to use, one of :rack, :rails, or :merb. (Default :rails)", descomente a linha
# Mesmo falando que o valor Default é Rails, tive problema, por não "setar" isso. Então faça!
config.webxml.booter = :rails

# Abaixo do comentário, iniciado por "Control the pool of Rails runtimes. Leaving unspecified means", descomente as linhas
config.webxml.jruby.min.runtimes = 2
config.webxml.jruby.max.runtimes = 4

# E no final de tudo adicione as seguintes linhas
# Tive problema, por não "setar" isso. Então você já sabe!
config.java_libs.reject! {
  |lib| lib =~ /jruby-complete|goldspike/
}

Feito tudo isso, salve o arquivo.

Vá para o Terminal!

# Para gerar o pacote WAR e seu respectivo diretório "explodido" execute
jruby -S warble

# Repare na última linha (!) que foi gerado pelo Warbler
jar cf registro.war -C tmp/war .

# Bom. Vamos voltar para o diretório do Apache Tomcat e editar o seu arquivo de configuração
cd .. && cd apache-tomcat-6.0.26 && mate conf/server.xml

No Editor!

<!-- Modificar a tag <Connector port="8080" /> para a informada abaixo -->
<Connector port="8080"
	maxHttpHeaderSize="8192"
	maxThreads="150"
	minSpareThreads="25"
	maxSpareThreads="75"
	enableLookups="false"
	redirectPort="8443"
	acceptCount="100"
	connectionTimeout="20000"
	disableUploadTimeout="true"
	compression="on"
	compressionMinSize="4096"
	compressableMimeType="text/plain, text/css, application/json, application/x-javascript, text/xml, application/xml, application/xml+rss, text/javascript, image/gif, image/jpg, image/png, */*"/>

<!-- Como também adicionar o seguinte conjunto de tags, acima ou abaixo da tag <Host name="localhost" /> -->
<Host name="registro.localhost"
			appBase="/users/andre/documents/workspace-ruby/registro/tmp/war"
			unpackWARs="true"
			autoDeploy="true"
			xmlValidation="false"
			xmlNamespaceAware="false">
	<Context path="" docBase="."/>
</Host>

Feito tudo isso, salve o arquivo.

Vá para o Terminal!

# Modificar o arquivos de Hosts do MacOSX
mate /etc/hosts

No Editor!

# Acrescentar o trecho abaixo a frente do IP 127.0.0.1
 registro.localhost

Feito tudo isso, salve o arquivo.

Vá para o Terminal!

# Pronto para ver nossa App funcionar? Então, voilà!
java -Xmx512m -Xms512m -XX:PermSize=256m -jar bin/bootstrap.jar

E feito, temos a nossa aplicação funcionando! Pronta para ser utilizada por pessoas comuns e não apenas nós Geek.

Bom é isso caro leitor.

Quem escreveu foi o André Moreira.
Obrigado pela visita e até o próximo post.

Qual o conjunto de ferramentas que você utiliza para testar, suas aplicações Rails? Pois eu já pratiquei um pouco de Test::Unit, nas camadas de Model e Controller. Como também testei o poder do SeleniumOnRails e a simplicidade do Webrat na camada de View.

Mas sempre sentia meio que um vazio nisso.

Por exemplo, depois de algumas semanas sem mexer no projeto, após voltar e ler os testes (é claro, como programador) era possível entender o que o sistema fazia. Porém queria saber se seria possível “clarear” ainda mais a idéia do código.

Então foi assim que obtive conhecimento do Trio Parada Dura.

Cenário

Sistema Operacional: Mac OSX
Dependências: Ruby, Git, Firefox, JSSH, Rails, Cucumber, RSpec e Watir

Problema

Testar da forma mais objetiva possível as 03 (três) camadas de um projeto Rails.

Mas desde já advirto! Essa não é uma solução definitiva. A mesma pode ser adaptada e melhorada para a sua maior comodidade.

Solução

Vou tentar ir direto ao assunto. Senão essa dica aqui vai ficar um pouco grande quanto por demais! Sendo que o processo é bem simples, não tenho muito o que comentar mesmo

Instalação

Dentro da raiz do seu projeto Rails, execute as seguintes linhas de comando:

Instalando a gem Cucumber.

script/plugin install --force git://github.com/aslakhellesoy/cucumber.git

Instalando a gem Database Cleaner, um complemento para o Cucumber.

script/plugin install --force git://github.com/bmabey/database_cleaner.git

Instalando a gem Cucumber Rails, um complemento para o Cucumber.

script/plugin install --force git://github.com/aslakhellesoy/cucumber-rails.git

Instalando a gem RSpec.

script/plugin install --force git://github.com/dchelimsky/rspec.git

Instalando a gem RSpec Rails, um complemento para o RSpec.

script/plugin install --force git://github.com/dchelimsky/rspec-rails.git

Instalando a gem Firewatir.

script/plugin install --force git://github.com/collin/firewatir.git

E ufa finalmente, instalando o addon JSSH, um complemento para Firefox.

Para isso baixe a respectiva versão via Wiki do Watir

Configuração

Após essas trocentas adições de gems, complementos, plugins e whatever… Vamos pedir para o Rails gerar os arquivos de configurações dos mesmos, via Terminal:

Para o RSpec.

script/generate rspec

Para o Cucumber.

script/generate cucumber --rspec

Já sobre o alerta disparado pelo Cucumber que segue, podemos desconsiderar. Pois não vamos usar o suporte do Webrat.

(::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::)
              (::)   D R I V E R   A L E R T    (::)
You didn't explicitly generate with --capybara or --webrat, so I looked at
your gems and saw that you had webrat installed, so I went with that.
If you want something else, be specific about it. Otherwise, relax.
(::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::)

Porém o Rails (ainda) não tem como gerar o arquivo de configuração, que integra o Cucumber com o Watir. Então faremos isso manualmente.

Através do seu editor de texto preferido (ex. Textmate), adicione as seguintes linhas ao final do arquivo, features/support/env.rb:

require 'firewatir'

BROWSER = Watir::Browser.start 'http://spoc_rb.localhost/'

After do
  BROWSER.close
end

Rápida explicação

E pronto! Já podemos começar a codificar os nossos Testes.

• Para testar o Model e o Controller, vamos utilizar o RSpec.
• E para testar a View, vamos utilizar o Cucumber com uma ajuda do Watir.

Esta certo. Mas você deve estar se perguntando:

E esse esse tal de Firewatir?!

Bom, o Watir disponibiliza pra gente a funcionalidade do código Ruby, executar a navegação nos elementos HTML e JavaScript (via JSSH). Porém para o Internet Explorer. Vulgo IEca!

E como sou um programador feliz, uso Firefox para desenvolvimento. Logo o que precisa ser instalado é a gem Firewatir

Exemplo de RSpec no Model

Vamos criar nosso teste com RSpec em spec/models/user_spec.rb:

# Run with command line: script/spec spec/models/user_spec.rb --color --format specdoc
# Or just do it on Mac: Command+R
require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')

describe User do
  before(:each) do
    @valid_attributes = {
      :name => 'Any User',
      :login => "anyuser",
      :password => '123change',
      :password_confirmation => '123change',
      :roles => %w[users_controller]
    }
  end

  context 'should validates the model' do
    it { User.new.should be_an_instance_of(User) }

    it 'should create a user' do
      @user = User.create! @valid_attributes
      @user.should be_valid
    end

    %w[name].each do |field|
      it "should require #{field}" do
        @user = User.new
        @user.should_not be_valid
        @user.errors.full_messages.should include("#{field.humanize} #{I18n.translate 'activerecord.errors.messages.blank'}")
      end
    end

    it 'should list all users without informing a parameter search' do
      @user = User.everyone nil, nil
      @user.size.should eql(4)
    end

    it 'should list all users informing a parameter search' do
      @user = User.everyone 'analyst', nil
      @user.size.should eql(1)
    end

    it 'should take the role of the first user found' do
      @user = User.first
      @user.roles.should eql(%w[users_controller])
    end

    it 'should list all roles' do
      @roles = User::ROLES
      @roles.size.should eql(1)
    end
  end
end

Para o seguinte arquivo app/models/user.rb:

class User < ActiveRecord::Base
  # Security
  attr_accessible :name, :login, :password, :password_confirmation, :roles

  # Validator
  validates_presence_of :name

  # Authlogic
  acts_as_authentic

  # <<Ability
  named_scope :with_role, lambda { |role| {:conditions => "roles_mask & #{2**ROLES.index(role.to_s)} > 0 "} }

  ROLES = %w[users_controller]

  def roles=(roles)
    self.roles_mask = (roles & ROLES).map { |r| 2**ROLES.index(r) }.sum
  end

  def roles
    ROLES.reject { |r| ((roles_mask || 0) & 2**ROLES.index(r)).zero? }
  end

  def role? role
    roles.include? role.to_s
  end
  # Ability>>

  # WillPaginate
  def self.everyone n_search, n_page
    if n_search
      paginate  :page => n_page,
                :per_page => 25,
                :conditions => ["name LIKE ? OR login LIKE ?",
                                "%#{n_search.strip}%",
                                "%#{n_search.strip}%"]
    else
      paginate  :page => n_page,
                :per_page => 25
    end
  end
end

E para executar, basta seguir o comentário que consta no arquivo acima e digitá-lo no Terminal:

script/spec spec/models/user_spec.rb --color --format specdoc

Que teremos a seguinte saída:

User should validates the model
- should be an instance of User(id: integer, name: string, login: string, crypted_password: string, password_salt: string, persistence_token: string, login_count: integer, failed_login_count: integer, last_request_at: datetime, current_login_at: datetime, last_login_at: datetime, current_login_ip: string, last_login_ip: string, created_at: datetime, updated_at: datetime, roles_mask: integer)
- should create a user
- should require name
- should list all users without informing a parameter search
- should list all users informing a parameter search
- should take the role of the first user found
- should list all roles
Finished in 0.291376 seconds
7 examples, 0 failures

Exemplo de RSpec no Controller

Vamos criar nosso teste com RSpec em spec/controllers/users_controller_spec.rb:

# Run with command line: script/spec spec/controllers/users_controller_spec.rb --color --format specdoc
# Or just do it on Mac: Command+R
require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')

describe UsersController do
  context 'should validates the controller' do
    it { UsersController.new.should be_an_instance_of(UsersController) }
  end

  context 'should validates the routes' do
    it 'should generate a route by GET from /users to { :controller=>"users", :action=>"index" }' do
      params_from(:get, users_path).should eql({ :controller=>'users', :action=>'index' })
    end

    it 'should generate a route by POST from /users to { :controller=>"users", :action=>"create" }' do
      params_from(:post, users_path).should eql({ :controller=>'users', :action=>'create' })
    end

    it 'should generate a route by GET from /users/new to { :controller=>"users", :action=>"new" }' do
      params_from(:get, new_user_path).should eql({ :controller=>'users', :action=>'new' })
    end

    it 'should generate a route by GET from /users/:id/edit to { :controller=>"users", :action=>"edit" }' do
      params_from(:get, '/users/1/edit').should eql({ :controller=>'users', :action=>'edit', :id => '1' })
    end

    it 'should generate a route by GET from /users/:id to { :controller=>"users", :action=>"show" }' do
      params_from(:get, '/users/1').should eql({ :controller=>'users', :action=>'show', :id => '1' })
    end

    it 'should generate a route by PUT from /users/:id to { :controller=>"users", :action=>"update" }' do
      params_from(:put, '/users/1').should eql({ :controller=>'users', :action=>'update', :id => '1' })
    end

    it 'should generate a route by DELETE from /users/:id to { :controller=>"users", :action=>"destroy" }' do
      params_from(:delete, '/users/1').should eql({ :controller=>'users', :action=>'destroy', :id => '1' })
    end
  end
end

Para o seguinte arquivo app/controllers/users_controller.rb:

class UsersController < ApplicationController
  # CanCan
  load_and_authorize_resource

  # /users (GET)
  def index
    @users = User.everyone params[:search], params[:page]
  end

  # /users/:id (GET)
  def show
  end

  # /users/new (GET)
  def new
  end

  # /users (POST)
  def create
    if @user.save
      flash[:notice] = 'Successfully created user.'
      redirect_to users_path
    else
      render :action => :new
    end
  end

  # /users/:id/edit (GET)
  def edit
  end

  # /users/:id (PUT)
  def update
    if @user.update_attributes params[:user]
      flash[:notice] = 'Successfully updated user.'
      redirect_to users_path
    else
      render :action => :edit
    end
  end

  # /users/:id (DELETE)
  def destroy
    @user.destroy
    flash[:notice] = 'Successfully eliminated user.'
    redirect_to users_path
  end
end

E para executar, basta seguir o comentário que consta no arquivo acima, e digitá-lo no Terminal:

script/spec spec/controllers/users_controller_spec.rb --color --format specdoc

Que teremos a seguinte saída:

UsersController should validates the controller
- should be an instance of UsersController
UsersController should validates the routes
- should generate a route by GET from /users to { :controller=>"users", :action=>"index" }
- should generate a route by POST from /users to { :controller=>"users", :action=>"create" }
- should generate a route by GET from /users/new to { :controller=>"users", :action=>"new" }
- should generate a route by GET from /users/:id/edit to { :controller=>"users", :action=>"edit" }
- should generate a route by GET from /users/:id to { :controller=>"users", :action=>"show" }
- should generate a route by PUT from /users/:id to { :controller=>"users", :action=>"update" }
- should generate a route by DELETE from /users/:id to { :controller=>"users", :action=>"destroy" }
inished in 0.088611 seconds
8 examples, 0 failures

Exemplo de Cucumber com Watir na View

Vamos criar nosso teste com Cucumber, que primeiramente se baseia em uma estória em features/user.feature:

# Run with command line: script/cucumber features/user.feature --format pretty
# Optional: script/cucumber features/user.feature --format pretty --tags @anything
@feature_user_registration
Feature: User Registration
  To register a User
  I need to have the role of analyst, supervisor or coordinator
  To do so, a new User can be registered in the system

  Background:
    Given access to the login page
    And inform my access credentials of analyst

  @scenario_registering_a_user
  Scenario: Registering a User
    Given click on the link Administration
    And after click on the link New
    When inform the credentials of a new User correctly
    Then I will have a new User registered

E depois vamos criar seu respectivo teste Ruby em features/step_definitions/background_steps.rb:

Before do
  BROWSER.link(:href, '/logout').click if BROWSER.html.include?('Logout')
end

Given /^access to the login page$/ do
  BROWSER.html.include?('Somebody ( Login )').should == true
  BROWSER.link(:href, '/login').click
end

And /^inform my access credentials of analyst$/ do
  BROWSER.html.include?('Login').should == true
  BROWSER.text_field(:name, 'user_session[login]').set 'analyst'

  BROWSER.html.include?('Password').should == true
  BROWSER.text_field(:name, 'user_session[password]').set '123change'

  BROWSER.button(:name, 'login').click
  BROWSER.html.include?('Successfully created user session.').should == true
end

E também em features/step_definitions/user_steps.rb:

Before do
  @login = Time.now.to_i
end

Given /^click on the link Administration$/ do
  BROWSER.html.include?('Administration').should == true
  BROWSER.link(:href, '/users').click
end

And /^after click on the link New$/ do
  BROWSER.html.include?('New').should == true
  BROWSER.link(:href, '/users/new').click
end

When /^inform the credentials of a new User correctly$/ do
  BROWSER.html.include?('Name').should == true
  BROWSER.text_field(:name, 'user[name]').set "Any User - #{@login}"

  BROWSER.html.include?('Login').should == true
  BROWSER.text_field(:name, 'user[login]').set "anyuser.#{@login}"

  BROWSER.html.include?('Password').should == true
  BROWSER.text_field(:name, 'user[password]').set '123change'

  BROWSER.html.include?('Password confirmation').should == true
  BROWSER.text_field(:name, 'user[password_confirmation]').set '123change'

  BROWSER.html.include?('Roles').should == true
  BROWSER.checkbox(:name, 'user[roles][]').click

  BROWSER.button(:name, 'save').click
end

Then /^I will have a new User registered$/ do
  BROWSER.html.include?('Successfully created user.').should == true
end

Agora para executar o nosso teste, primeiro nós devemos ativar o suporte do componente JSSH, via Terminal digitando:

/Applications/Firefox.app/Contents/MacOS/firefox-bin -jssh

Após isso, agora sim, basta seguir o comentário que consta no arquivo feature, e digitá-lo no Terminal:

script/cucumber features/user.feature --format pretty

Que teremos a seguinte saída:

Using the default profile...
# Run with command line: script/cucumber features/user.feature --format pretty
# Optional: script/cucumber features/user.feature --format pretty --tags @anything
@feature_user_registration
Feature: User Registration
  To register a User
  I need to have the role of analyst, supervisor or coordinator
  To do so, a new User can be registered in the system
  Background:                                   # features/user.feature:9
    Given access to the login page              # features/step_definitions/background_steps.rb:5
    And inform my access credentials of analyst # features/step_definitions/background_steps.rb:10
  @scenario_registering_a_user
  Scenario: Registering a User                          # features/user.feature:14
    Given click on the link Administration              # features/step_definitions/user_steps.rb:5
    And after click on the link New                     # features/step_definitions/user_steps.rb:10
    When inform the credentials of a new User correctly # features/step_definitions/user_steps.rb:15
    Then I will have a new User registered              # features/step_definitions/user_steps.rb:34
1 scenario (1 passed)
6 steps (6 passed)
0m8.039s

Aprendo mais sobre desenvolvimento guiado por comportamento

A dica de hoje, foi baseada sobre diversas fontes de estudos, que tive a oportunidade de ler no decorrer dessas últimas semanas.

Claro que existe muito mais do que foi exemplificado aqui. Então corra, corra atrás…

De conteúdo pago.

• The RSpec Book: Behaviour Driven Development with Rspec, Cucumber, and Friends
• RSpec: Designing and Implementing Testing in Rails

Como também gratuito.

• Cucumber: Tutorials and Related Blog Posts
• Cucumber: Examples
• Cucumber: Wiki
• RSpec: Documentation
• RSpec Rails: Documentation
• RSpec: Wiki
• RSpec: David Chelimsky
• Watir: Documentation
• Watir: Examples

Bom é isso caro leitor.

Quem escreveu foi o André Moreira.
Obrigado pela visita e até o próximo post.

Durante o dia-a-dia do meu estudo, estudo, codificação e pausa para o café acabo me deparando com algum problema que é simples de resolver. Mas se eu não ficar atento! Essa pequena bola de neve, pode me soterrar

E como atualmente estou com a mania de criar Procedimento, no meu atual trabalho de Helpdesk, para tudo o que eu faço. Resolvi adotar por aqui também esse mesmo estilo, para repassar conhecimento.

Espero que seja útil!

Cenário

Sistema Operacional: Mac OSX
Dependências: Ruby e Xcode

Problema

Recentemente precisei instar no meu Querido MacBook Pro uma RubyGem do PostgreSQL, para fazer o Ruby conversar com esse “Sistema Gerenciador de Banco de Dados Objeto Relacional”. Ufa! Que quatrocentão esse camarada

E depois de executar a linha de comando a seguir, via Terminal:

sudo gem install pg

Me deparo com o erro:

Building native extensions.  This could take a while...
ERROR:  Error installing pg:
ERROR: Failed to build gem native extension.

Solução

Trocando umas idéias com o Tio Google, fiquei sabendo que é preciso utilizar o código abaixo. Junto da mesma linha de comando, para que o Ruby entenda a arquitetura do processador em uso (bem resumidamente é isso).

env ARCHFLAGS=”-arch SUA_ARQUITETURA_AQUI”

Logo temos a seguintes arquiteturas (principais):

• i386
• x86_64

Depois que entendemos isso, basta digitar o comando inicial, com a adição da ARCHFLAGS, conforme abaixo:

PATH=$PATH:/Library/PostgreSQL/8.4/bin sudo env ARCHFLAGS="-arch i386" gem install pg -- --with-pgsql-include=/Library/PostgreSQL/8.4/include --with-pgsql-lib=/Library/PostgreSQL/8.4/lib

Apenas uma rápida finalização aqui. Pois preciso explicar porque a linha de instalação ficou tão GIGANTE assim

O código abaixo disponibiliza os arquivos binários do PostgreSQL no PATH no MacOSX

PATH=$PATH:/Library/PostgreSQL/8.4/bin

Já o trecho abaixo informa que o meu PostgreSQL é de arquitetura i386

sudo env ARCHFLAGS="-arch i386" gem install pg

Por último deixo claro para o GCC em quais locais estão os Inclues de Libs do PostgreSQL

-- --with-pgsql-include=/Library/PostgreSQL/8.4/include --with-pgsql-lib=/Library/PostgreSQL/8.4/lib

Agora é só usar a gem pg e continuar sendo feliz.

Bom é isso caro leitor.

Quem escreveu foi o André Moreira.
Obrigado pela visita e até o próximo post.

Recentemente tive dificuldade, para fazer o Nginx funcionar no meu querido Mac OSX.

Apesar de basicamente não existir problema durante a instalação, somente após o termino dessa, tive algumas dores de cabeça. Mas, como o problema agora já consta resolvido, vou compartilhar com vocês a solução que adotei.

Introdução

Senão for do seu conhecimento, o Nginx, é um Servidor e Proxy Reverso HTTP de Alta Performance. Óoo, como soa bonita essa frase !

Porém os motivos em adotar esse servidor foram de alguns artigos da comunidade, como esse da Caelum (por Fábio Kung) e esse daqui também da Boox-box (por Marco Gomes), comentando sobre a baixa quantidade de Memória e CPU que esse servidor consome.

Assim esse foi o motivo da minha pessoa, querer utilizar o Nginx desde o desenvolvimento, passando por qualidade até chegar com aplicação em produção.

A instalação

Nem precisei pedir ajuda do Tio Google, pois no Twitter mesmo já recebi comentários sobre o Nginx + Passenger… Então, vamos ao que interessa!

Para saber como efetuar a instalação básica do Passenger com Nginx, basta seguir esse Screencast:

Quick Time: http://www.modrails.com/videos/passenger_nginx.mov

Feito isso não somente o meu Mac OSX, como o seu também, deve executar sua aplicação Ruby em segundos (isso mesmo Nginx é muito rápido).

Porém, nem tudo é satisfação. Piada boba essa.

DNS error – cannot find server

Foi esse o primeiro erro que tive de resolver, após configurar a minha primeira aplicação Ruby.

Agora sim, mais do que nunca, o Tio Google me indicou o post de um rapaz da comunidade Ruby BR (só que agora não me lembro o link, então depois coloco por aqui). Esse artigo diz que eu preciso editar o arquivo de Hosts do Mac OSX, conforme abaixo.

# Via Terminal
sudo mate /etc/hosts

# No querido Textmate
# Modificar essa linha
127.0.0.1 localhost

# Para essa daqui
127.0.0.1 localhost my.application

Feito isso: Problema Resolvido! Na sinceridade, somente um bug corrigido.

HTTP 403

No meu caso esse erro, não foi resolvido utilizando o comando Unix conhecido, por Chmod. O problema, não tinha nada a ver com essa solução.

Acontece que o Nginx executa-se com “um usuário próprio”, na qual esse não tem previlégios no sistema de arquivo fora de sua alçada (leia-se /opt/nginx/html) então é preciso informar isso no arquivo de configuração do mesmo.

E somando isso, mais o Gist do @MauricioJr, o problema foi resolvido (e finalmente) da seguinte forma:

# Via Terminal
sudo mate /opt/nginx/conf/nginx.conf

# No querido Textmate
# Modificar essa linha
# user nobody; << Isso mesmo a linha esta comentada

# Para essa daqui
user my_user_mac my_group_mac;

E pronto o problema esta resolvido. No meu caso o item my_group_mac, substitui por admin e o item my_user_mac para andre.

Conclusão

Sempre tente corrigir um problema através da Documentação, mas se esta não estiver clara (para você), informe a sua dúvida (específica) em algum Grupo de Usuários.

Bom é isso caro leitor.

Quem escreveu foi o André Moreira.
Obrigado pela visita e até o próximo post.

Atualmente tenho estudado Ruby e todas as facilidades que existem em volta dessa linguagem.

Algo que me chamou muito atenção e me fez balançar a relação que tenho com Java hoje Foram das Pessoas que escrevem código em Ruby, existir um sentimento muito forte, sobre ser Agile.

Aonde dentre esses aspectos da Agile, mais especificamente na Extreme Programing o ponto que mais gosto é de escrever testes antes de programar uma funcionalidade.

Um pequeno cenário

Eu escrevo testes é claro. Seria loucura programar em plena atualidade Sem testar o meu código!

Mas o pouco que já pude notar, das Pessoas que escrevem código tanto em PHP como em Java. É mais ou menos a seguinte situação:

Você esta vendo essa especificação (fluxogramas e afins)? Já esta tudo documentado, então é Só Escrever o Código, pra fazer isso funcionar. Não precisa testar nada!

Simplesmente fico e torço o nariz!

Você pode até pensar, que Eu sou “louco” em “gastar tempo” escrevendo Testes enquanto programo.

Além de achar esquisito demais, em Eu tentar trazer Você para esse lado da força

Mas brincadeiras a parte! Vou pedir para Você, humildemente ler as seguintes postagens e ficar mais abismado com os comentários do Phillip Calçado:

• Uh-eme-ele
• Programadores profissionais escrevem testes. Ponto final

Pois é chato passar por situações, na qual colegas programadores comentam:

Você esta maluco??? Não tenho tempo para ficar testando meus códigos!

Velhinho a minha felicidade como Programador fica

Sabe, realmente essa bronca que Algumas Pessoas tem por testar código, não é melhor caminho da highway!

Então venho aqui, para repassar essa idéia a você. Isso mesmo apenas repassar!

Por onde começar?

Esses dias via Twitter, um colega postou uma apresentação sobre Testes, mas muuuito boa! Conforme slide a seguir, você precisa ver.

Demonstra Testes em Ruby, porém sem preconceitos (se tiver é claro)! Alias, como Carlos Brando costuma dizer a melhor linguagem de programação é o programador.

Ufa! Quantos slides. Mas bem interessante.

Depois de assistir os slides (não tive o prazer de estar no local) resolvi listar aqui, uma fatia das ferramentas para Teste, nas linguagens que costumo programar.

Primeiramente TDD, que nada mais é do que Desenvolver Orientado a Teste.

Com Java

• JUnit
• TestNG

Com PHP

• PHPUnit
• SimpleTest

Com Python

• unittest

Com Ruby

• Test::Unit

E não que os próximos itens descritos, sejam um complemento. Mas encaro como sendo uma segunda alternativa ao TDD. Temos assim o BDD, que é Desenvolver Orientado a Comportamento.

Com Java

• JBehave

Com PHP

• PHPSpec

Com Python

• Pyccuracy

Com Ruby

• RSpec
• Cucumber

Agora é só você começar a escrever seus testes!

Bom é isso caro leitor.

Quem escreveu foi o André Moreira.
Obrigado pela visita e até o próximo post.

Após alguns meses afastado do blog, por causa de uma maratona de cursos que vinha fazendo aos finais de semana, estou na área novamente para comentar que o blog ainda existe

Como atualmente estou atarefado em um projeto, não terei cabeça pra falar sobre Design Patterns. Mas (bem) futuramente volto a destrinchar esse assunto.

Tema de hoje

O assunto da vez é Como aprender Java. Que surgiu após alguns colegas, que desconhecem essa maravilhosa linguagem Orientada a Objetos, ficarem falando:

- Poxa vida André, gostaria de programar em Java também. Mas como é muito difícil, nem me aventuro.

Obs.: Linguagem maravilhosa é ótimo

Primeiramente vamos deixar claro o seguinte. Java não é simplesmente mais uma linguagem de programação! Java ultrapassa esse paradigma, pelo menos Eu encaro dessa forma. Através disso nós temos na verdade Plataformas muito abrangentes e distintas de desenvolvimento, quando falamos em Java.

Apresento a você (resumidamente é claro) algumas siglas que fazem os pilares do que Java é hoje:

O Java SE, aqui temos o Core dessa Gente Grande, que constitui de uma Java Virtual Machine (vulgo HotSpot ou se preferir JVM) que irá interpretar e executar o código que você escreve, compilador que ira gerar a partir dos seus arquivos .java, arquivos .class que serão executados pelo HotSpot e uma extensa API. Logo é por aqui que se inicia a sua aprendizagem! Para instalar vide esse link da JDK.

Obs.: A JVM é sem dúvida uma maravilha, agora não estou exagerando

Temos também o Java EE, que além de integrar o que existe de disponível na Java SE, essa plataforma foi pensada exclusivamente para aplicações que envolvem diversas camadas e conforme especificação roda em um Servidor de Aplicações (mas não necessariamente) e também possui sua própria API. Onde na minha opinião é a plataforma mais interessante de utilizar. Para instalar vide esse link da SDK.

Por último, não menos importante temos o Java ME. Pois é através desse que conseguimos escrever Aplicações Embarcadas (se você achar esse nome um pouco esquisito, vale apena dar uma conferida nesse podcast). Ou seja tudo quanto for dispositivo/aplicação especifica, por exemplo: Celulares, PDAs, Eletroeletrônicos e afins. Podemos aproveitar das diversas APIs (CLDC, MID Profile, CDC, Foundation e etc…) que compõem o Java ME e escrever soluções que também funcionem fora de um computador seja ele desktop, notebook ou server.

Agora olhando para tudo isso acima, realmente Java não é uma Ilha (:-0 puts que trocadilho chinfrim) e sim um mundo das melhores tecnologias disponíveis no mercado, escritas em Java. Como por exemplo o RPC e o WebServices.

Agora que já temos uma breve noção sobre em qual lugar Java pode ser aplicado. Vamos nos atentar em como aprender essa extensa Linguagem de Programação.

Livros

Toda faculdade (pelo menos aqui em São Paulo, Brasil) sempre aponta como material base, o livro Java Como Programar, do famoso Deitel, que nessa postagem se encontra em sua 6ª edição.

Afinal de contas, gostei de Java por causa desse livro também! É claro que cheguei a estudar outros livros como:

• Programando em Java 2 – Teorias e Aplicações
• A Arte do Java
• Aplicando Lógica Orientada a Objetos em Java
• Programação Orientada a Aspectos em Java

Mas nesse livro do Deitel, você passa praticamente de capitulo em capitulo, sempre lendo e relendo assuntos relacionados ao Core do Java. Ou seja, como costumo brincar, você aprende Java na marra ou reforça a cada capitulo o que já aprendeu

Agora falando (um pouco) sério, todo iniciante deve se preocupar em aprender os tópicos: Classe, Atributo, Método, Objeto, Estrutura de Controle, Array, Herança, Polimorfismo, Exceção, Recursão, Pesquisa, Ordenação, Estrutura de Dado, Formatação de Saída de Dado, String, Caractere, Expressão Regular, Generic, Collection, Thread, Socket e JDBC.

Pois o cidadão sabendo isso ele depois pode partir para outros temas relacionados ao Java. Pois como citado anteriormente é apenas o básico-do-básico!

Apostilas

Se você não quiser comprar algum dos livros citados aqui, você pode assim digamos, baixar versões genéricas do mesmo em websites (underground) espalhados por aí. Lembrando que o material encontrado sempre será em inglês. Então para os que não tem muita intimidade com o idioma do Tio San, pode procurar por apostilas escritas em bom é claro português e de graça!

Obs.: A leitura de versões genéricas são de sua e única responsabilidade :-O

Uma das apostilas que costumo sempre recomendar, são as da Caleum. Que é de uma escola que fica localizada aqui em São Paulo e em mais duas outras cidades (Rio de Janeiro e Porto Alegre).

É claro que apesar do conteúdo das apostilas serem bons, se você quiser, pode pagar pelo curso e ter aulas com ótimos instrutores. Além de aumentar seu networking com os alunos, instrutores e cia.

Agora chega de propaganda e vamos as apostilas:

• FJ-11 – Java e Orientação a Objetos
• CS-14 – Algoritmos e Estruturas de Dados em Java

Estude ambas do começo ao fim, primeiramente a FJ-11 e depois a CS-14 e com certeza você estará preparado para após a leitura e entendimento dessas apostilas a dizer:

- Agora sim sei como programar em Java.

Grupos de Usuários

Algo que você notará ao estudar, trabalhar e continuar a conhecer Java é de que sempre existiram pessoas que defendem fervorosamente essa Linguagem e/ou alguns aspectos da mesma. E saiba que você também pode dar sua contribuição para esse grupo.

A seguir deixo uma listagem de algumas comunidades Java que costumo visitar:

• GUJ
• Java Free
• GO Java
• GU Java SC
• JEE Brasil
• Portal Java

Portais

Como falei existe bastante gente interessada na utilização de Java. A seguir mais uma lista que deve constar em seus favoritos:

• Sun
• IBM
• Oracle
• InfoQ
• DZone
• Java World

Blogs

Então, nem preciso comentar

• Ricardo Ferreira
• Camilo Lopes
• Cláudio Miranda
• Diego Plentz
• Edgar Silva
• Phillip Calçado
• Guilherme Chapiewski
• Igo Coelho
• Java Bahia
• Luca Bastos
• Rafael Carneiro
• Rafael Ponte
• Tiago Peczenyj
• Zona J

Metodologias de Desenvolvimento

Agora essa parte não vale somente para Java, mas sim para Programação em sí. Quando possível, aplique metodologias como XP em seu ambiente de trabalho. Pode ser outra metodologia similar, sem problema algum. Mas tente fugir (o quanto possível) do modelo Waterfall.

Pois lidamos (e sempre lidaremos) com pessoas, que precisam (e sempre necessitaram) de software funcional! Então que tal deixá-las felizes?

Bom é isso caro leitor.

Quem escreveu foi o André Moreira.
Obrigado pela visita e até o próximo post.

Continuando o assunto sobre Padrões de Projeto. Hoje será a vez de falar de uma turma que é muito influente, no ramo de desenvolvimento de software. Mais conhecida como a Gangue dos Quatro.

Mas antes, vamos falar de dois outros personagens

Na década de 70, dois conhecidos programadores Kent Beck e Ward Cunningham perceberam que os conceitos mencionados pelo Cristopher (o professor do post passado), resolveriam muito dos problemas relacionados a programação de sistemas de computador. Logo aplicaram as teorias do Cristopher, através de uma linguagem de programação largamente utilizada naquela época.

Mr. Kent

Mr. Ward

Falo aqui do SmallTalk, a mãe do que hoje conhecemos por
OO (apesar de alguns detestarem)

Mas e o GoF surgiu dessa época, certo?

Não! Avançando algumas décadas, na nossa maquina do tempo, foi na décadacde 90 que o quarteto Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides
. Escreveram o conceituado livro: Design Patterns: Elements of Reusable Object-Oriented Software.

E após isso ficaram conhecidos como a Gangue dos Quatro ou no inglês
Gang of Four. Logo temos aí o motivo da sigla do que hoje conhecemos por GoF Patterns.

A estrutura do GoF

E com essas quatro feras no time, a quantidade de padrões que a turma do GoF levantou, não foram poucas. Temos nada mais, nada menos do que 23 maneiras de resolver alguns problemas e esses estam estruturados em 3 categorias, que são conhecidas por:

• Creational Pattern
• Structural Pattern
• Behavioral Pattern

Se bem que, se formos vasculhar hoje na Internet e nas livrarias, vamos identificar outros padrões, além da quantidade já citado anteriormente.

Então vamos falar brevemente sobre cada uma das estruturas:

• Creational Pattern, nos auxilia em resolver problemas na criação dos nossos objetos.
• Structural Pattern, foca nas associações existentes entre nossas classes e objetos.
• Behavioral Pattern, temos por último esse que trata dos problemas de divisão da responsabilidade entre as nossas classes e objetos.

O que veremos a seguir?

Nos próximos posts veremos na pratica a utilização de cada pattern. Por enquanto deixo aqui a lista dos 23 e mais alguns patterns que fazem parte da família GoF.

Creational Pattern

• Abstract factory
• Factory method
• Builder
• Lazy initialization
• Object pool
• Prototype
• Singleton (sem comentá)

Structural pattern

• Adapter
• Aggregate
• Bridge
• Composite
• Decorator
• Extensibility
• Facade
• Flyweight
• Proxy
• Pipes and filters
• Private class data

Behavioral pattern

• Chain of responsibility
• Command
• Interpreter
• Iterator
• Mediator
• Memento
• Null Object
• Observer
• State
• Strategy
• Specification
• Template method
• Visitor
• Single-serving visitor
• Hierarchical visitor

Bom é isso caro leitor.

Quem escreveu foi o André Moreira.
Obrigado pela visita e até o próximo post.

O título desse post, que tentarei explicar se desdobrará durante vários artigos. Deixarei esclarecido que esse tema será abordado de forma mais pratica possível. Deixando de lado alguns pontos demasiadamente teóricos, para literatura indicada via link, no decorrer de cada post.

Logo a minha intenção nessa série de artigos (futuramente) será de detalhar os seguintes tópicos, relacionados a Padrões de Projeto: nome do padrão, problema levantado, solução proposta, quando implementar e respectiva conseqüência.

A Origem

Essa discussão é nova? Devo “perder tempo” estudando isso? Então vamos lá!

Cristopher Alexander

Um pouco de história. Padrões de Projeto ou no inglês Design Patterns, teve como precursor o professor austríaco Cristopher Alexander. Alias a Áustria esta de parabéns, nesse país de algumas cabeças pensantes existiram muitas contribuições para humanidade. Mas, cá entre nós qual foi a contribuição do Cristopher? A do Conceito sobre Padrões de Projeto!

Graças a iniciativa nos anos 70, desse professor emérito, que escreveu livros como: Notes on the Synthesis of Form, The Timeless Way of Building e A Pattern Language. Entre outros que podem ser conferidos em livrarias por aí… O Cristopher mostrou a “nós programadores”, a porta de entrada, de uma maneira interessantíssima de resolver problemas, adotando padrões.

Antes de prosseguirmos, uma pergunta:

- Para você o que caracteriza um Padrão de Projeto? (Não vale pedir ajuda do Tio, apenas diga alguma característica que venha a mente)

Agora vamos lá, voltar aos anos 70 e compreender um pouco sobre essa história. Naquela época se da a entender que o arquiteto Cristopher precisava de uma linguagem padrão, para auxiliar ele e seus colegas de trabalho a projetarem, construírem e repassar esse conhecimento de uma forma que terceiros compreendessem e executassem tais métodos.

Assim podemos acreditar que após muitos projetos de arquitetura entregues, um pleno estudo sobre o que poderia ser e não ser padronizado, foi que Cristopher identificou as seguintes características, que passariam a abordar o conceito sobre Padrões de Projeto, que são:

Encapsulamento

Conseguir separar uma solução em partes, tentando isola-las ao máximo. Tornando assim a solução do problema, a mais flexível, de fácil modificação e futuras implementações possíveis.

Nota: nada de criar soluções engessadas!

Generalidade

Tornar que um padrão seja o meio para determinada solução de um problema. Ou até mesmo em caso de uma ocorrência, “desse padrão” não facilitar ou deixar deselegante a solução do problema. Podemos aproveitar a teoria do mesmo para propor uma nova solução e como conseqüência um “novo padrão”.

Equilíbrio

Podemos entender por equilíbrio, a utilização do padrão propriamente dito aplicado em um projeto. Ao proceder dessa maneira, deixamos para traz todo dilema que envolve: porque determinada tarefa e mais problemática dessa forma? Será possível melhorar essa lentidão do processo… Entre outras questões que são comumente levantadas, enquanto o problema não é solucionado. Ou seja, enquanto não encontramos o padrão adequado.

Nota: até agora essas características são bem sustentáveis, logo no decorrer das demais, estará mais do que comprovado, que a adoção bem aplicada de padrões é um bom caminho.

Abstração

Esse termo abstração pode parecer meio complexo. Mas na verdade ele auxilia no simples ponto de extrair ao máximo um problema levantado. Ao em vez de focar no problema por um todo, focamos apenas no essencial, naquilo que dá inicio a problemática. Durante o projeto, conforme surja alguma necessidade é claro, podemos abstrair digamos, um nível a mais a complexidade de determinado “artefato”.

Abertura

Tal como falado anteriormente no item Generalidade. Quando Cristopher acrescenta o item Abertura como sendo uma característica em Padrões de Projeto. Nada mais ele esta confirmando, caso seja necessário, no decorrer do caminho depararmos com uma incompletude em determinado padrão, podemos complementa-lo e deixar tal padrão mais detalhado. Não necessariamente construindo um novo padrão, mas sim buscar melhorar e/ou complementar um padrão já existente.

Combinatoriedade

E pra finalizar, o austríaco citado até o momento, nada mais quer dizer no item Combinatoriedade, “de que o todo é mais do que a simples soma de suas partes” mencionadas até esse momento. Falando mais tecnicamente, podemos entender que existiram relacionamentos entre os Padrões de Projeto do nível mais baixo com os padrões de nível mais alto. Concluindo assim o conceito sobre quais são as característica envolvidas em Padrões de Projeto.

Então é isso galera. Espero que tenha conseguido transmitir, nesse singelo artigo, um tema que considero importante para “nós”. E assim ressaltar que nós como programadores, não analista de sistemas e nem tão pouco digitadores, devemos também dedicar um tempo a assuntos como esse discutido aqui.

No próximo artigo falarei sobre o Padrão de Projeto GoF e (tentarei) mostrar os seus respectivos diagramas de classe (ou código mesmo). Afinal de contas UML serve muito bem pra isso. Mas devemos lembrar que GoF não é a única (coletânea) padrão, existem outros como: GRASP Patterns, J2EE Patterns, Testing Patterns, Optimization Coding Patterns, Robustness Coding Patterns, Organizational Coding Patterns e etc…

E o importante mesmo é saber quando utilizar cada pattern, senão, ao em vez de resolver um problema, acabamos duplicando a problemática do mesmo.

Bom é isso caro leitor.

Quem escreveu foi o André Moreira.
Obrigado pela visita e até o próximo post.