Quando tentava instalar, ocorria o seguinte erro:

[bash]
*** extconf.rb failed ***
Could not create Makefile due to some reason, probably lack of
necessary libraries and/or headers.  Check the mkmf.log file for more
details.  You may need configuration options.

Provided configuration options:
–with-opt-dir
–without-opt-dir
–with-opt-include
–without-opt-include=${opt-dir}/include
–with-opt-lib
–without-opt-lib=${opt-dir}/lib
–with-make-prog
–without-make-prog
–srcdir=.
–curdir
–ruby=/usr/local/bin/ruby
[/bash]

Instalando dependências

[bash]
sudo aptitude install libperl-dev
sudo aptitude install libmagickwand-dev
sudo aptitude install libmagickcore-dev libmagick++-dev
[/bash]

Instalando ImageMagick

E qual foi a solução? Adivinha! Tive de fazer o donwload e compilar “na mão” o ImageMagick. Instalar o mesmo utilizando aptitude,
apt-get não resolvia. Então, faça os seguintes procedimentos para também ser feliz.

[bash]
wget ftp://ftp.fifi.org/pub/ImageMagick/ImageMagick-6.5.7-10.tar.gz
tar -vzxf ImageMagick-6.5.7-10.tar.gz
cd ImageMagick-6.5.7-10/
./configure
make
sudo make install
[/bash]

Instalando RMagick

Agora finalmente poderemos instalar a nossa gem RMagick

[bash]
gem install rmagick
[/bash]

E é isso ai! Sucesso!

Instalação:

[bash]

pacman -S postgresql

[/bash]

Startando banco de dados

[bash]

/etc/rc.d/postgresql start

[/bash]

Criando o usuário do PostgreSQL

[bash]
groups postgres
su root
su – postgres
createuser <username>
[/bash]

Adaptador para o Rails

[bash]
gem install pg
[/bash]

Criando projeto rails com PostgreSQL

Pronto. Agora é só criar seu projeto rails voltado para o postgresql

[bash]
rails <nome_projeto> –d=postgresql
[/bash]

Agora configure seu arquivo database.yml com o usuário e senha que você criou acima.
Abraços

Aqui na Voraz, deixamos de utilizar o Ubuntu e passamos a utilizar o Arch sem nenhum problema, e com um ganho de performance enorme.

Hoje vamos preparar o arch para desenvolvimento de aplicações rails e php com o banco de dados mysql.

MySql

[shell]
pacman -S mysql
/etc/rc.d/mysqld start
/usr/bin/mysqladmin -u root password ‘seu_password’
[/shell]

Php

Existem diversas alternativas para rodarmos php e nginx juntos, utilizaremos aqui o spawn-cgi

[shell]
pacman -S php-cgi php-mcrypt
yaourt -S spawn-fcgi
[/shell]

Agora abra seu arquivo /etc/php/php.ini

[shell]
#verifique se a pasta que você utilizará como root no nginx na linha open_basedir. Se não tiver, adicione
open_basedir = /srv/http/:/home/:/tmp/:/usr/share/pear/:/root/

#libere os módulos que deseja, no meu caso são esses:
extension=bz2.so
extension=mcrypt.so
extension=mysql.so
extension=zip.so
[/shell]

Para startar o php basta utilizar o seguinte comando:

[shell]
spawn-fcgi -a 127.0.0.1 -p 9000 -f /usr/bin/php-cgi &
[/shell]

Rvm

O rvm, que nos permite utilizar várias versões do Ruby .

[shell]
pacman -S git #caso ainda não tenha o git instalado.
mkdir -p ~/.rvm/src/ && cd ~/.rvm/src && rm -rf ./rvm/ && git clone –depth 1 git://github.com/wayneeseguin/rvm.git && cd rvm && ./install
[/shell]

Reinicie seu terminal e caso não tenha o comando “rvm”, adicione a seguinte linha ao seu .bashrc e reinicie o terminal novamente.

[shell]
if [[ -s /usr/local/rvm/scripts/rvm ]] ; then source /usr/local/rvm/scripts/rvm ; fi
[/shell]

Agora vamos instalar as versões 1.8.7 e 1.9.1 do ruby e setar a versão padrão a ser utilizada.

[shell]
rvm install 1.8.7,1.9.1
rvm –default 1.9.1
[/shell]

e algumas gems:

[shell]
gem update
gem install gem_plugin rails
gem install mongrel –source http://gems.rubyinstaller.org/">http://gems.rubyinstaller.org #para ruby 1.9.1
[/shell]

Nginx / Passenger

Nginx é um servidor leve, de baixo consumo de memória e alta performance e com arquivos de configuração bem claros e simples.

Na Voraz, substituímos o apache pelo nginx e não temos do que reclamar. O passenger nos permite rodar aplicações rails diretamente no nginx (ou no apache). Vamos a instalação:

[shell]
gem install passenger
passenger-install-nginx-module
[/shell]

O segundo comando irá baixar e compilar o nginx já com o módulo do passenger instalado. Agora vamos fazer uma configuração básica do nginx. Abra o arquivo /opt/nginx/conf/nginx.conf

[shell]
worker_processes  1;

error_log  logs/error.log;

http {
passenger_root /usr/local/rvm/gems/ruby-1.9.1-p378/gems/passenger-2.2.11;
passenger_ruby /usr/local/rvm/rubies/ruby-1.9.1-p378/bin/ruby;

include       mime.types;
default_type  application/octet-stream;

access_log off;

sendfile        on;

keepalive_timeout  65;

client_max_body_size 15m;

autoindex on;

index  index.html index.htm index.php;

charset utf-8;

include fastcgi_params;
include /opt/nginx/sites-enabled/*;
}
[/shell]

Vá ao arquivo /opt/nginx/conf/fastcgi_params (provavelmente você só precisará adicionar a ultima linha)

[shell]

fastcgi_param  QUERY_STRING       $query_string;
fastcgi_param  REQUEST_METHOD     $request_method;
fastcgi_param  CONTENT_TYPE       $content_type;
fastcgi_param  CONTENT_LENGTH     $content_length;

fastcgi_param  SCRIPT_NAME        $fastcgi_script_name;
fastcgi_param  REQUEST_URI        $request_uri;
fastcgi_param  DOCUMENT_URI       $document_uri;
fastcgi_param  DOCUMENT_ROOT      $document_root;
fastcgi_param  SERVER_PROTOCOL    $server_protocol;

fastcgi_param  GATEWAY_INTERFACE  CGI/1.1;
fastcgi_param  SERVER_SOFTWARE    nginx/$nginx_version;

fastcgi_param  REMOTE_ADDR        $remote_addr;
fastcgi_param  REMOTE_PORT        $remote_port;
fastcgi_param  SERVER_ADDR        $server_addr;
fastcgi_param  SERVER_PORT        $server_port;
fastcgi_param  SERVER_NAME        $server_name;

# PHP only, required if PHP was built with –enable-force-cgi-redirect
fastcgi_param  REDIRECT_STATUS    200;

fastcgi_param  SCRIPT_FILENAME    $document_root$fastcgi_script_name;
[/shell]

Vamos criar a pasta /opt/nginx/sites-enabled onde deixaremos os arquivos de configuração de nossos sites e o arquivo /opt/nginx/sites-enabled/0-default

[shell]
server {
listen          80;
server_name     localhost;
root            /root/voraz;

error_page   500 502 503 504  /50x.html;
location = /50x.html {
root   html;
}
location ~ \.php$ {
fastcgi_pass   127.0.0.1:9000;
}
}
[/shell]

Desse modo, todas as requisições a arquivos .php serão encaminhadas ao pgp-cgi. Agora vamos criar um novo arquivo de configuração para uma aplicação rails: /opt/nginx/sites-enabled/teste-rails

[shell]
server{
server_name         sindicato.org.br www.sindicato.org.br;
root                /root/voraz/teste-rails/public; #deve sempre apontar para a pasta public
passenger_enabled   on;
rails_env           production;
}
[/shell]

Para finalizar, alguns comandos do nginx:

[shell]
/opt/nginx/sbin/nginx #start o nginx
/opt/nginx/sbin/nginx -s stop #para o nginx
/opt/nginx/sbin/nginx -s reload #retarta o nginx
[/shell]

Como alguns devem saber, estou implementando para meu tcc um software que dentre outras coisas realiza o self-organizing-map, de Kohonen. Tal algoritmo não é tão complexo a nível de programação, mas como grande parte dos algoritmos de Inteligência Artificial, ele consome muito processamento.

Devido a isso, realizei diversas implementações (actionscript, ruby puro, ruby e c++) – em breve disponibilizarei – e o que realmente me chamou atenção foi quanto a performance da nova versão que nesse teste, foi quase 2x mais rápida:

Ruby 1.8:

[bash]script/performance/benchmarker 2 Train.test_rb
user     system      total        real
#1     39.510000   7.040000  46.550000 ( 46.574937)
#1     41.900000   7.060000  48.960000 ( 49.245010)
#1     42.260000   7.020000  49.280000 ( 49.644825)
[/bash]

Ruby 1.9:

[bash]script/performance/benchmarker 2 Train.test_rb
user     system      total        real
#1     28.100000   0.060000  28.160000 ( 28.193008)
#1     26.790000   0.100000  26.890000 ( 27.049028)
#1     27.150000   0.060000  27.210000 ( 27.616277)
[/bash]

É (ou já passou) a hora de mudar.

Irei tratar do Faker. Para quem não o conhece, o mesmo é responsável por gerar dados fictícios sendo eles dados pessoais, empresariais, endereços enfim, muitas coisas. Garantindo assim uma grande praticidade.

O primeiro passo e óbvio é instalarmos o Faker.

[bash]
sudo gem install faker
[/bash]

Acessando a documentação, você poderá perceber a quantidade de coisas que ele é capaz de gerar. Faça um teste no console, abra-o e faça um require ‘faker’ e é só brincar.

Alguns exemplos

[bash]
#fazendo o require da gem
>> require ‘faker’
=> true

#Nomes
>> Faker::Name.name
=> "Arlo Moore"

#Sobrenomes
>> Faker::Name.last_name
=> "Stoltenberg"

#Cidades
>> Faker::Address.city
=> "Jerrellfort"
[/bash]

Chega de brincar e vamos a proposta do post: Gerar exemplares inteligentes.

Primeiramente, instale o plugin object_daddy para que possamos utilizar os exemplares. Pois, é com ele que utilizaremos o .generate na hora de popularmos o banco.

[bash]
script/plugin install git://github.com/flogic/object_daddy.git
[/bash]

Caso você utilize rspec, crie dentro da pasta spec uma pasta chamada exemplars e aqueles que não utilizam, crie dentro da pasta test.

Usuários rspec:

Não usuários rspec:

Agora dentro da pasta criada, você irá criando os exemplares de seus models. Por exemplo no meu caso tenho o model User. Então dentro desta pasta criarei um arquivo user_exemplar.rb. Em outras palavras é o nome do model seguido do sufixo ‘_exemplar.rb‘.

O exemplar inicialmente ficará assim:

[ruby]
class User

end
[/ruby]

Vamos ao que interessa! =)
Considera-se que minha classe de usuário possua os atributos: nome, sobrenome, nome da rua, número da casa e nome da cidade. Se fosse no modo convencional, ficaria assim:

[ruby]
class User
generator_for :name, “Adriano”
generator_for :sobrenome, “Tadao”
generator_for :street, “Rua Americana”
generator_for :number, “104”
generator_for :city, “Birigui”
end
[/ruby]

Mas como nos interessa um model inteligente capaz de gerar usuários de nomes diferentes isso ai não nos interessa! Ao invés de informarmos um valor estático, setaremos um método em seu lugar. Veja o exemplo:

[ruby]
class User
generator_for :name, :method=>:some_name
generator_for :surname, :method=>:some_surname
generator_for :street, :method=>:some_street
generator_for :number, :method=>:some_number
generator_for :city, :method=>:some_city

#Faremos com que os nomes sejam todos diferentes, para isso utilizaremos o while para garantir que não se repetirá
def self.some_name
begin
last_name = Faker::Name.name
end while User.find_by_name(last_name)!=nil

last_name
end

#Como o sobrenome não importa se irá repetir ou não, fica simples assim
def self.some_surname
Faker::Name.last_name
end

#Nome da rua que também poderá repetir
def self.some_street
Faker::Address.street_name
end

#O número da casa que este não utilizará o faker, apenas sorteará números de até três dígitos
def self.some_number
rand(999)
end

#O nome da cidade que também poderá ser repetido
def self.some_city
Faker::Address.city
end

end
[/ruby]

Ok! Nosso exemplar já está apto a popular nosso banco de dados. Veja como será o processo agora.

Abra o console (script/console) da aplicação em questão e faça o require do faker.

[bash]
>> require ‘faker’
=> []

#Gerar uma única vez
>> User.generate
=> #<User id: 3, name: "Camila Hamill", created_at: "2009-10-15 23:07:50", updated_at: "2009-10-15 23:07:50", surname: "Sauer", street: "Dixie Route", number: 152, city: "Yostfort">

#Gerar determinada quantidade de usuários.
>> 10.times{ User.generate }
=> 10

[/bash]

Para gerar determinada quantidade de vezes a sintax é a seguinte:

[bash]
[Quantidade].times{ [Model].generate }
[/bash]

Note no seu banco que está tudo lá gerado e salvo.

Abraços

Ao trabalho!

O primeiro passo é você criar o model que extenda a classe ActionMailer que será o responsável pelo envio dos e-mails.

[bash]
script/generate mailer email
exists  app/models/
create  app/views/email
exists  test/unit/
create  test/fixtures/email
create  app/models/email.rb
create  test/unit/email_test.rb
[/bash]

Feito isso, será criado um model vazio.

[ruby]
class Email < ActionMailer::Base
end
[/ruby]

Agora criaremos uma função que terá a finalidade de montar todo nosso email.

[ruby]
class Email < ActionMailer::Base

def register_email(para, de, assunto, mensagem)
recipients para
from de
subject assunto
sent_on Time.now
body mensagem
content_type "text/html"
end

end[/ruby]

No exemplo acima, a função recebe os valores de parâmetro tudo separadamente. Nada o impede de criar uma função que receba um único objeto. É possível enviar a mensagem (body) tanto como texto normal ou como html. Case queira enviar para mais de um e-mail, basta enviar os e-mails em questão dentro de um array que ele automaticamente enviará para todos

Até agora temos o model baseado no ActionMailer com uma função que criará nosso e-mail. O próximo passo é configurarmos o arquivo config/enviroment.rb mas por quê? Por que o ruby precisa de uma conta que será responsável por fazer os envios

Abra seu enviroment.rb que se encontra na pasta config e deixe-o similar ao exemplo. Adicione estas linhas lá no final do documento.

[bash]
#Exemplo: Configurando para deixar o adriano@voraz.com.br como o email responsável:

ActionMailer::Base.smtp_settings =
{
:address => "smtp.voraz.com.br",
:port=>’25′,
:domain => "voraz.com.br",
:user_name => "adriano@voraz.com.br",
:password => "*******",
:authentication  => :login
}
[/bash]

Entenda a sintax:

[ruby]

Email.deliver_register_email([para quem vai], [quem está enviando], [assunto], [mensagem])

[/ruby]

Na prática:

[ruby]
#corpo da mensagem em html
body = "<b>Data e horário:</b> #{Time.now.strftime(‘%d/%m/%y’)} – #{Time.now.strftime(‘%H:%M’)}\n"
body << "<b>Nome:</b> Adriano\n"
body << "<b>E-mail:</b> adriano@voraz.com.br\n"
body << "<b>Telefone:</b> 18 – 3641 4382\n\n"
body << "<b>Assunto:</b>Testando o envio de e-mail \n"
body << "<b>Mensagem:</b> Apenas teste"

#Aqui faz o envio

Email.deliver_register_email(“adriano@voraz.com.br”, “voraz@voraz.com.br”, "Teste do envio", body)
[/ruby]

Note o prefixo deliver_ antes da função que criamos inicialmente. O mesmo é responsável por enviar nosso email. Não se esqueça dele pois nada funcionará.

Bem simples não?

Abraços