25 Aug 07 O que você acha de gerar um executável da sua aplicação Ruby On Rails para fazer um demo ou apresentar para um cliente?

Como o título já diz: O que você acha de gerar um executável da sua aplicação Ruby On Rails para fazer um demo ou apresentar para um cliente?

Pois é, acabei de descobrir que isto é possível

Para isto vamos precisar das seguintes ferramentas:

• Tar2RubyScript – é um utilitário que transforma uma estrutura de diretórios com uma aplicação Ruby em um único arquivo .rb
• RubyScript2Exe – é um utilitário que cria um executável a partir de um script ruby, com a grande vantagem de ja ter todo o necessário para executar este script, ou seja já inclui o Interpretador do Ruby e todas as libs necessárias, o melhor é que ele filtra o que vai se incluido, não sendo necessário incluir toda a stdlib por exemplo.

Para instalar ambos, basta executar os comandos:

$sudo gem install tar2rubyscript
$sudo gem install rubyscript2exe

Para começar, vamos criar uma aplicação RoR, mas para poder carregar tudo junto com o executável, vamos utilizar o banco de dados SQLite.

Criando a aplicação

$rails demo
$cd demo
$ruby script/server

Acesse com o browser o endereço: http://localhost:3000/ para garantir que esta tudo OK.

Criando o banco de dados

$irb

irb(main):005:0> require 'sqlite3'
irb(main):006:0> SQLite3::Database.new("demo_dev.db").execute(
irb(main):007:1* "create table books (id integer primary key,   \
irb(main):008:1"                      title varchar(255),       \
irb(main):009:1"                       author varchar(255));")

E copiaremos o banco criado para as bases de produção e testes:

$cp demo_dev.db demo_test.db
$cp demo_dev.db demo_prod.db

Desenvolvendo a aplicação Rails

$vi config/database.yml

Substituimos o conteúdo com algo parecido com isto:

development:
  adapter: sqlite3
  database: demo_dev.db
test:
  adapter: sqlite3
  database: demo_tst.db

production:
  adapter: sqlite3
  database: demo_prd.db

Criamos o model e o controller:

$script/generate model Book
$script/generate controller Book
$vim app/controllers/book_controller.rb

E alteramos o código para algo parecido com isto:

class BookController < ApplicationController
scaffold :book
end

$script/server

Acesse com o browser o endereço http://localhost:3000/book para ver se esta tudo OK.

Criando o Ruby Archive

Agora a parte nova (fala sério, até o meu gato já sabe criar um CRUD com scaffold )

O comando Tar2RubyScript cria um pacote para a aplicação, mas quando executado, ele descompacta tudo em um diretório temporário e no final da execução ele limpa o diretório, o que não é exatamente o comportamento esperado, então vamos mover os dados para um local seguro antes da execução …

$vi config.environment.rb

E vamos adicionar o seguinte código no inicio do arquivo:

module Rails
  class Configuration
    def database_configuration
      conf = YAML::load(ERB.new(IO.read(database_configuration_file)).result)
      if defined?(TAR2RUBYSCRIPT)
        conf.each do |k, v|
          if v["adapter"] =~ /^sqlite3/
            v["database"] = oldlocation(v["database"]) if v.include?("database")
            v["dbfile"]   = oldlocation(v["dbfile"])   if v.include?("dbfile")
          end
        end
      end
      conf
    end
  end
end

Isto vai alterar a forma como o rails encontra o banco de dados, que originalmente estava definido assim:

module Rails
  class Configuration
    def database_configuration
      YAML::load(ERB.new(IO.read(database_configuration_file)).result)
    end
  end
end

O que exatamente foi feito? quando executado um RBA precisa tratar dois diretórios diferentes: o diretório onde aplicação esta sendo executada, e o diretório onde a aplicação esta realmente ( referenciado como oldlocation), o código apresentado altera as configurações do database.yml colocando o caminho completo para o banco de dados e não apenas o nome do arquivo como seria utilizado em uma aplicação normal.

O Tar2RubScript precisa também de um arquivo chamado init.rb que sera o ponto de partida da aplicação, vamos cria-lo com o seguinte conteúdo:

$vi init.rb

at_exit do
  require "irb"
  require "drb/acl"
  require "sqlite3"
end

load "script/server"

Os ‘require’ adicionados são para facilitar a detecção de quais bibliotecas o programa utiliza, ja que o Rails carrega algumas delas apenas durante a execução do sistema, assim o Tar2RubyScript vai poder incluir estas bibliotecas também no executável gerado.

Agora vamos finalmente empacotar a aplicação:

$cd ..
$tar2rubyscript demo
$cp demo/demo_* .

Prontinho, ja podemos testar o nosso Ruby Archive

$ruby demo.rb

Pode acessar novamente a aplicação pela URL: http://localhost:3000/book

Criando um executável para levar para o cliente

Criar o executável não é nada complicado, basta executar o comando:

$rubyscript2exe demo.rb

Depois que o rails inicializar, precione CTRL+C e sera criado um executável de nome demo.exe, ou demo_linux no linux que é o meu caso.

Basta copiar o executável e os arquivos de banco de dados para o

Conclusões

Não será necessário chegar no cliente e instalar Ruby, RubyGems, Rails, outros Gems, …

Apenas um executável e alguns arquivos de bancos de dados no seu pendrive e esta tudo pronto para o demo

O que você quer melhor que isto?
Na verdade a única coisa que faltou para mim, foi a possibilidade de no linux gerar um executável windows para facilitar os demos, mas mesmo assim, ja esta mais do que bom

PS.: tirei este passo a passo desta URL, eu fiz alguns ajustes no código e traduzi o texto, o maior ajuste foi a utilização de sqlite3