Rails e Stubs

controller

Description

Stubs out a new controller and its views. Pass the controller name, either CamelCased or under_scored, and a list of views as arguments.
To create a controller within a module, specify the controller name as a path like parent_module/controller_name.
This generates a controller class in app/controllers, view templates in app/views/controller_name, a helper class in app/helpers, a functional test suite in test/functional and a helper test suite in test/unit/helpers.

Example

  ./script/generate controller CreditCard open debit credit close

Credit card controller with URLs like /credit_card/debit.

  Controller:      app/controllers/credit_card_controller.rb   Functional Test: test/functional/credit_card_controller_test.rb   Views:           app/views/credit_card/debit.html.erb [...]   Helper:          app/helpers/credit_card_helper.rb   Helper Test:     test/unit/helpers/credit_card_helper_test.rb

Modules Example

  ./script/generate controller 'admin/credit_card' suspend late_fee

Credit card admin controller with URLs /admin/credit_card/suspend.

  Controller:      app/controllers/admin/credit_card_controller.rb   Functional Test: test/functional/admin/credit_card_controller_test.rb   Views:           app/views/admin/credit_card/debit.html.erb [...]   Helper:          app/helpers/admin/credit_card_helper.rb   Helper Test:     test/unit/helpers/admin/credit_card_helper_test.rb

integration_test

Description

Stubs out a new integration test. Pass the name of the test, either CamelCased or under_scored, as an argument. The new test class is generated in test/integration/testname_test.rb

Example

  ./script/generate integration_test GeneralStories

creates a GeneralStories integration test in test/integration/general_stories_test.rb

model

Description

Stubs out a new model. Pass the model name, either CamelCased or under_scored, and an optional list of attribute pairs as arguments.
Attribute pairs are column_name:sql_type arguments specifying the model's attributes. Timestamps are added by default, so you don't have to specify them by hand as created_at:datetime updated_at:datetime.
You don't have to think up every attribute up front, but it helps to sketch out a few so you can start working with the model immediately.
This generates a model class in app/models, a unit test in test/unit, a test fixture in test/fixtures/singular_name.yml, and a migration in db/migrate.
Examples:

  ./script/generate model account

creates an Account model, test, fixture, and migration:

  Model:      app/models/account.rb   Test:       test/unit/account_test.rb   Fixtures:   test/fixtures/accounts.yml   Migration:  db/migrate/XXX_add_accounts.rb

  ./script/generate model post title:string body:text published:boolean

creates a Post model with a string title, text body, and published flag.

migration

Description

Stubs out a new database migration. Pass the migration name, either CamelCased or under_scored, and an optional list of attribute pairs as arguments.
A migration class is generated in db/migrate prefixed by a timestamp of the current date and time.
You can name your migration in either of these formats to generate add/remove column lines from supplied attributes: AddColumnsToTable or RemoveColumnsFromTable

Example

  ./script/generate migration AddSslFlag

If the current date is May 14, 2008 and the current time 09:09:12, this creates the AddSslFlag migration db/migrate/20080514090912_add_ssl_flag.rb

  ./script/generate migration AddTitleBodyToPost title:string body:text published:boolean`

This will create the AddTitleBodyToPost in db/migrate/20080514090912_add_title_body_to_post.rb with this in the Up migration:

add_column :posts, :title, :string   add_column :posts, :body, :text   add_column :posts, :published, :boolean

And this in the Down migration:

remove_column :posts, :published   remove_column :posts, :body   remove_column :posts, :title

mailer

Description

Stubs out a new mailer and its views. Pass the mailer name, either CamelCased or under_scored, and an optional list of emails as arguments.
This generates a mailer class in app/models, view templates in app/views/mailer_name, a unit test in test/unit, and fixtures in test/fixtures.

Example

  ./script/generate mailer Notifications signup forgot_password invoice

creates a Notifications mailer class, views, test, and fixtures:

  Mailer:     app/models/notifications.rb   Views:      app/views/notifications/signup.erb [...]   Test:       test/unit/test/unit/notifications_test.rb   Fixtures:   test/fixtures/notifications/signup [...]

plugin

Description

Stubs out a new plugin. Pass the plugin name, either CamelCased or under_scored, as an argument. Pass –with-generator to add an example generator also.
This creates a plugin in vendor/plugins including an init.rb and README as well as standard lib, task, and test directories.

Example

   ./script/generate plugin BrowserFilters

creates a standard browser_filters plugin:

  vendor/plugins/browser_filters/README   vendor/plugins/browser_filters/init.rb   vendor/plugins/browser_filters/install.rb   vendor/plugins/browser_filters/lib/browser_filters.rb   vendor/plugins/browser_filters/test/browser_filters_test.rb   vendor/plugins/browser_filters/tasks/browser_filters_tasks.rake

./script/generate plugin BrowserFilters --with-generator

creates a browser_filters generator also:

  vendor/plugins/browser_filters/generators/browser_filters/browser_filters_generator.rb   vendor/plugins/browser_filters/generators/browser_filters/USAGE   vendor/plugins/browser_filters/generators/browser_filters/templates/

scaffold

Description

Scaffolds an entire resource, from model and migration to controller and views, along with a full test suite. The resource is ready to use as a starting point for your RESTful, resource-oriented application.
Pass the name of the model (in singular form), either CamelCased or under_scored, as the first argument, and an optional list of attribute pairs.
Attribute pairs are column_name:sql_type arguments specifying the model's attributes. Timestamps are added by default, so you don't have to specify them by hand as created_at:datetime updated_at:datetime.
You don't have to think up every attribute up front, but it helps to sketch out a few so you can start working with the resource immediately.
For example, scaffold post title:string body:text published:boolean gives you a model with those three attributes, a controller that handles the create/show/update/destroy, forms to create and edit your posts, and an index that lists them all, as well as a map.resources :posts declaration in config/routes.rb.
If you want to remove all the generated files, run script/destroy scaffold ModelName.
Examples:

./script/generate scaffold post ./script/generate scaffold post title:string body:text published:boolean ./script/generate scaffold purchase order_id:integer amount:decimal

session_migration

Description

Creates a migration to add the sessions table used by the Active Record session store. Pass the migration name, either CamelCased or under_scored, as an argument.

Example

  ./script/generate session_migration CreateSessionTable

With 4 existing migrations, this creates the AddSessionTable migration in db/migrate/005_add_session_table.rb

metal

Description

Cast some metal!
Examples:

  ./script/generate metal poller

This will create: Metal: app/metal/poller.rb

observer

Description

Stubs out a new observer. Pass the observer name, either CamelCased or under_scored, as an argument.
The generator creates an observer class in app/models and a unit test in test/unit.

Example

  ./script/generate observer Account

creates an Account observer and unit test:

  Observer:   app/models/account_observer.rb   Test:       test/unit/account_observer_test.rb

resource

Description

Stubs out a new resource including an empty model and controller suitable for a restful, resource-oriented application. Pass the singular model name, either CamelCased or under_scored, as the first argument, and an optional list of attribute pairs.
Attribute pairs are column_name:sql_type arguments specifying the model's attributes. Timestamps are added by default, so you don't have to specify them by hand as created_at:datetime updated_at:datetime.
You don't have to think up every attribute up front, but it helps to sketch out a few so you can start working with the resource immediately.
This creates a model, controller, helper, tests and fixtures for all of them, and the corresponding map.resources declaration in config/routes.rb
Unlike the scaffold generator, the resource generator does not create views or add any methods to the generated controller.
Examples:

  ./script/generate resource post # no attributes   ./script/generate resource post title:string body:text published:boolean   ./script/generate resource purchase order_id:integer amount:decimal

helper

Description

Stubs out a new helper. Pass the helper name, either CamelCased or under_scored.
To create a helper within a module, specify the helper name as a path like parent_module/helper_name.
This generates a helper class in app/helpers and a helper test suite in test/unit/helpers.

Example

  ./script/generate helper CreditCard

Credit card helper.

Helper:     app/helpers/credit_card_helper.rb Test:       test/unit/helpers/credit_card_helper_test.rb

Modules

Example

  ./script/generate helper 'admin/credit_card'

Credit card admin helper.

  Helper:     app/helpers/admin/credit_card_helper.rb   Test:       test/unit/helpers/admin/credit_card_helper_test.rb

performance_test

Description

Stubs out a new performance test. Pass the name of the test, either CamelCased or under_scored, as an argument. The new test class is generated in test/performance/testname_test.rb

Example

  ./script/generate performance_test GeneralStories

creates a GeneralStories performance test in test/performance/general_stories_test.rb

Redmine em Ambiente Windows

Tutorial de Instalação do Redmine em Ambiente Windows+Apache+Mongrel+MySQL

Configuração de um servidor de produção para o Redmine, em ambiente Windows, servidor http Apache+Mongrel, acessando base de dados armazenada no MySQL. Este post tem a finalidade de descrever esse processo, passo a passo.

Requisitos

Windows XP SP2: este tutorial foi feito utilizando um XP SP2 previamente instalado. Provavelmente funcionará sem problemas em outras versões de Windows.
Apache Webserver 2.x: neste tutorial foi utilizada a versão “Win32 Binary without crypto (no mod_ssl) (MSI Installer)” que pode ser obtida no endereço: http://ftp.unicamp.br/pub/apache/httpd/binaries/win32/apache_2.2.11-win32-x86-no_ssl.msi
One-Click Ruby Installer: neste tutorial foi utilizada a versão “One-Click Ruby Installer 1.8.6-25″ que pode ser obtida no endereço: http://rubyforge.org/frs/download.php/18566/ruby186-25.exe
MySQL: neste tutorial foi utilizada a versão “mysql-essential-5.1.31-win32″ que pode ser obtida no endereço: http://ftp.astral.ro/mirrors/mysql.com/Downloads/MySQL-5.1/mysql-essential-5.1.31-win32.msi
Redmine: neste tutorial foi utilizada a versão “redmine-0.8.1″ que pode ser obtida no endereço: http://rubyforge.org/frs/download.php/51748/redmine-0.8.1.zip

Instalação do Apache Web Server

1.Execute o instalador do Apache Webserver, clicando sobre o arquivo “apache_2.2.11-win32-x86-no_ssl.msi” a partir do Windows Explorer. Clique então sobre o botão “Next”.


2.Selecione a opção “I accept the terms…” e clique sobre o botão “Next”.


3.Clique sobre o botão “Next”.


4.Informe os endereços solicitados e clique no botão “Next”.


5.Selecione a opção “Typical” e clique sobre o botão “Next”.


6.Clique sobre o botão “Change…” para alterar o caminho onde o servidor será instalado.


7.Informe o caminho desejado. Neste tutorial utilizamos o caminho “c:\apache”. Clique sobre o botão “Ok”.


8.Clique sobre o botão “Next”.


9.Clique sobre o botão “Install”.


10.Clique sobre o botão “Finish”.


11.Teste se o servidor foi instalado corretamente, digitando “http://localhost” no campo url do browser. Se tudo estiver ok, a tela apresentada será semelhante a tela abaixo:

Instalação do Ruby

1.Execute o instalador do Ruby, clicando sobre o arquivo “ruby186-25.exe” a partir do Windows Explorer. Clique então sobre o botão “Next”.


2.Clique sobre o botão “I Agree”.


3.Clique sobre o botão “Next”.


4.Informe o caminho desejado. Neste tutorial utilizamos o caminho “c:\ruby”. Clique sobre o botão “Next”.


5.Clique sobre o botão “Install”.


6.Clique sobre o botão “Next”.


7.Clique sobre o botão “Finish”.

Instalação dos pacotes Rails, Mongrel, Win32 Services

1.Os próximos passos serão executados em linha de comando do Windows, para isso clique no botão iniciar do Windows. Clique em “Executar” e na linha de comando digite “cmd” e pressione a tecla “Enter”. Todas as operações levam alguns minutos e é necessário que você esteja conectado à internet.
2.Mude para o diretório “c:\ruby\bin” e digite o comando de atualização do gerenciador de pacotes do Ruby RubyGems:
gem update --system
3.Digite o comando de atualização e instalação do Rails:

Obs: Em uma instalação no Windows Vista tive o seguinte erro:
C:\ruby\bin>gem install rails
ERROR: While executing gem ... (Errno::ENOENT)
No such file or directory - C:\Users\André Dourado
Provavelmente pelo espaço no caminho do diretório. Setei a variável “userprofile” para o diretório do ruby e o problema foi solucionado.
C:\ruby\bin>set userprofile=c:\ruby

gem install rails
4.Digite o comando de atualização e instalação do Mongrel:
gem install mongrel
5.Digite o comando de atualização e instalação do suporte aos serviços Win32:
gem install win32-service
6.Digite o comando de atualização e instalação do mongrel como serviço Win32:
gem install mongrel_service

Instalação do MySQL

1.Execute o instalador do MySQL, clicando sobre o arquivo “mysql-essential-5.1.31-win32.msi” a partir do Windows Explorer. Clique então sobre o botão “Next”.


2.Clique sobre o botão “Next”.


3.Clique sobre o botão “Change”.


4.Entre com o caminho da instalação, no caso “c:\mysql”. Clique sobre o botão “Ok”.


5.Clique sobre o botão “Next”.


6.Clique sobre o botão “Install”.


7.Clique sobre o botão “Next”.


8.Clique sobre o botão “Next”.


9.Clique sobre o botão “Finish”.


10.Clique sobre o botão “Next”.


11.Clique sobre o botão “Next”.


12.Clique sobre o botão “Next”.


13.Clique sobre o botão “Next”.


14.Clique sobre o botão “Execute”.


15.Clique sobre o botão “Finish”.

Instalação do Redmine

1.Clique com o botão da direita sobre o arquivo zip do Redmine e selecione a opção “Extrair tudo…”. Ao abrir o “Assistente para extração” clique no botão “Avançar”. Na próxima tela, no campo de diretório de destino, digite “c:\apache\htdocs”.


2.Para facilitar a navegação pelos diretórios do aplicativo, renomeie o diretório criado pelo Redmine de “redmine-0.8.1” para apenas “redmine”;
3.Copie o arquivo “config\database.yml.example” para “config\database.yml”. Neste tutorial utilizamos o banco de dados MySql, com o usuário “root” sem senha e será executado em nossa máquina local. Para este setup a seção “production:” do arquivo “database.yml”, deve ficar:
production:
adapter: mysql
database: redmine
host: localhost
username: root
password:
encoding: utf8
4.Os próximos passos serão executados em linha de comando do Windows, para isso clique no botão iniciar do Windows. Clique em “Executar” e na linha de comando digite “cmd” e pressione a tecla “Enter”.
5.Mude para o diretório “c:\mysql\bin” e digite o comando de execução do mysql para o usuário “root” no banco de dados mysql.
mysql -u root mysql
6.Crie a estrutura do banco de dados “redmine” com o comando:
create database redmine character set utf8;
7.Saia do MySql digitando o comando “quit” e pressionando a tecla “Enter”.
8.Mude para o diretório do redmine “c:\apache\htdocs\redmine”. Crie a estrutura do banco de dados “redmine”, digitando o comando:
\ruby\bin\rake db:migrate RAILS_ENV=production
9.Insira os dados padrão de configuração no banco de dados, digitando o comando:
\ruby\bin\rake redmine:load_default_data RAILS_ENV=production
Ao ser solicitado para informar a língua desejada, digite “pt-br” e pressione a tecla “Enter”.
10.Instale o serviço que irá executar o servidor Mongrel para o Redmine na porta 4000, digitando o comando:
\ruby\bin\mongrel_rails service::install -N Redmine -c c:\apache\htdocs\redmine -p 4000 -e production
11.Inicie o serviço, digitando o comando:
net start Redmine
12.Através do browser teste se o Redmine está no ar. Acesse o endereço “http:\\localhost:4000\login”

Configuração do Apache

1.Crie o arquivo de configuração de proxy para a aplicação “c:\apache\conf\http-proxy-redmine.conf”, com o seguinte conteúdo:
LoadModule proxy_module modules/mod_proxy.so
LoadModule proxy_http_module modules/mod_proxy_http.so
ProxyRequests Off

Order deny,allow
Allow from all
Alias /redmine “C:/apache/htdocs/redmine/public”

Options Indexes FollowSymLinks
AllowOverride none
Order allow,deny
Allow from all
ProxyPass /redmine/images !
ProxyPass /redmine/stylesheets !
ProxyPass /redmine/javascripts !
ProxyPass /redmine/ http://127.0.0.1:4000/
ProxyPass /redmine http://127.0.0.1:4000/
ProxyPassReverse /redmine http://127.0.0.1:4000/
2.Edite o arquivo de configuração do Apache “c:\apache\conf\httpd.conf”. Acrescente na última linha do arquivo a seguinte linha:
Include conf/http-proxy-redmine.conf
3.Reinicie o serviço do Apache pelo gerenciador de serviços do Windows.

Configuração do Proxy Reverso

O Rails cria internamente endereços de URL para links de folha de estilo, que faz com que a aplicação não execute da forma correta, através do proxy do Apache. Utilizaremos um plugin do Rails, que altera o modo como as URLs são criadas.
1.Mude para o diretório do redmine “c:\apache\htdocs\redmine”. Instale o plugin, digitando o comando abaixo. Responda para a url base “c:\apache\htdocs\redmine” e para a versão do Rails, escolha a opção “3″:
\ruby\bin\ruby script/plugin install http://svn.napcsweb.com/public/reverse_proxy_fix


2.Reinicie o serviço do Redmine pelo gerenciador de serviços do Windows.

Teste do Redmine pelo Proxy

1.Através do browser teste se o Redmine está no ar, sendo acessado pelo proxy configurado no Apache. Acesse o endereço “http:\\localhost\redmine\login”


Post Relacionados:
Tutorial Redmine – Gráficos no Redmine usando a API do Google Charts
Referências:
Serving Multiple Rails Applications on Windows with Apache and Mongrel
Mongrel Win32 HOWTO

O que é Ruby on Rails?

Ruby on Rails é um framework de desenvolvimento web escrito na linguagem Ruby. Ele é designado para tornar a programação de aplicações web mais fácil, fazendo várias suposições sobre o que cada desenvolvedor precisa para começar. Ele permite que você escreva menos código enquanto faz mais que muitas outras linguagens e frameworks. Desenvolvedores Rails mais experientes também dizem que ele torna o desenvolvimento de aplicações web mais divertido.

O Rails é um software com opinião. Isto é, ele supõe que existe um modo melhor para fazer as coisas, e ele é desenhado para encorajar este modo – e em alguns casos desencorajando alternativas. Se você aprender “O Modo Rails” vai provavelmente descobrir um aumento tremendo de produtividade. Se persistir em trazer velhos hábitos das outras linguages para o desenvolvimento Rails, tentando usar padrões que aprendeu em outros lugares, você pode ter uma experiência menos divertida.

A filosifia Rails inclui diversos princípios guia:

DRY – “Don’t Repeat Yourself” – sugere que escrever o mesmo código várias vezes é uma coisa ruim.

Convenção ao invés de Configuração – significa que o Rails faz suposições sobre o que você quer fazer e como você estará fazendo isto, em vez de deixá-lo mudar cada minúscula coisa através de intermináveis arquivos de configuração.

REST é o melhor modelo para aplicações web – organizar sua aplicação em torno de recursos e verbos HTTP padrão é o modo mais rápido para proceder.

Ruby on Rails foi uma extração de David Heinemeier Hansson de um projeto seu, o gerenciador de projetos Basecamp. Foi lançado a público pela primeira vez em julho de 2004.

Esta excelente definição do que é Rails está disponível no Rails Guide.

• Página oficial (em inglês e português)
• Ruby Installer - Instalador para Windows
• Download
• Documentação
• Ebooks sobre ruby
• Tutoriais
• Artigos

O que é Ruby?

Ruby é uma linguagem de programação interpretada multiparadigma, de tipagem dinâmica e forte, com gerenciamento de memória automático, originalmente planejada e desenvolvida no Japão em 1995, por Yukihiro “Matz” Matsumoto, para ser usada como linguagem de script.

Ruby suporta programação funcional, orientada a objetos, imperativa e reflexiva. Foi inspirada principalmente por Python, Perl, Smalltalk, Eiffel, Ada e Lisp, sendo muito similar em vários aspectos a Python. Atualmente, Ruby é a 10º linguagem de programação mais popular do mundo, de acordo com o Índice Tiobe.

Ruby possui repositórios de bibliotecas disponíveis em sites como Ruby Forge e Ruby Application Archive (RAA). Existe, ainda, uma ferramenta de instalação de bibliotecas, chamada RubyGems, semelhante aos gerenciadores de pacotes do Linux, como o APT. O projeto mais famoso desenvolvido em Ruby é o meta-framework Ruby on Rails.

A linguagem Ruby está disponível para diversas plataformas, como Microsoft Windows, Linux, Solaris e Mac OS X, além de também ser executável em cima da máquina virtual Java (através doJRuby) e haver um projeto para ser executável em cima da máquina virtual Microsoft .NET, o IronRuby.

Esta definição do que é a linguagem Ruby está disponível na wikipédia (além de outros detalhes).

• Página oficial (em inglês e português)
• Ruby Installer - Instalador para Windows
• Download
• Documentação
• Ebooks sobre ruby
• Tutoriais
• Artigos

Rails no Microsoft IIS

Rails no Microsoft IIS

Categoria: Artigos

A Microsoft anunciou suporte total ao FastCGI em seu software para servidores - Internet Information Services (IIS). O alvo primário do anúncio é o PHP (a “FastCGI Extension” foi desenvolvida pela Microsoft em conjunto com a Zend).
“By supporting the open standard, Microsoft has made it possible for PHP and other CGI compliant languages to be hosted efficiently and effectively on Windows Server 2003 and IIS.”
A parte importante para desenvolvedores Rails é “and other CGI compliant languages.”
“The IIS FastCGI support enables IIS to host normal CGI programs like PHP, or Ruby On Rails, using the FastCGI protocol, offering high-performance and stability for production deployment of such application frameworks.”


Veja neste post como habilitar o IIS para rodar aplicações Rails, usando o FastCGI.

Rails - Um exemplo de Aplicação

Introdução

Estamos assumindo que você já tem o Rails instalado e tem uma noção de programação e sql.

Para iniciar o nosso estudo sobre Rails estamos propondo desenvolver uma aplicação simples onde cadastramos filmes e informações referentes a estes filmes. Todas as vezes que citarmos algum exemplo será sempre focado no desenvolvimento da aplicação, assim teremos um exemplo prático da utilização de Ruby em Rails, com isso pretendemos facilitar o processo de entendimento da linguagem e da ferramenta. Os exemplos citados serão feitos utilizando GNU/Linux.

Instalando Rails no Debian

Para instalar o rails basta instalar o pacote debina rails com o comando:

aptitude install rails

Instalando Rails no Windows 

A instalação no windows é um processo extremamente simples e rápido. Baixe o one click instaler e ele mesmo vai realizar todo o processo necessário. Ruby on click Installer

Iniciando uma aplicação

Para iniciar uma aplicação em Rails basta digitar o comando:

rails nome_da_aplicação

Nosso caso:

rails Filmes

Com este comando o Rails cria uma estrutura para o desenvolvimento da aplicação. Um pacote rails fornece a lógica de controle para as aplicações, unindo a apresentação e o mapeamento de objetos em uma biblioteca MVC (Model-View-Controller) completa.

Esta estrutura é ilutrada abaixo:

• Filmes: Diretório raiz da aplicação. este diretório terá o mesmo nome que foi escolhido para a nome_da_aplicação anteriormente.
• app: Neste diretório estará toda a árvore de diretórios onde construiremos a nossa aplicação, portanto este é o diretório mais importante :).
• controllers: contém o C do MVC, neste diretório estão os arquivos que fazem o processamento da requisições e invocam as outras partes do sistema;
• helpers: Contém funções auxiliares para os controlers;
• models: Possui os objetos que mapeiam o banco de dados para a aplicação;
• views: Contém os arquivos responsáveis pela apresentação do site;
• components
• config
• db
• doc
• lib
• log
• public
• Rakefile
• README
• script: Possui alguns scripts explicar melhor a utilizadade e os scripts mais comuns.
• test
• tmp
• vendor 

Iniciando o servidor

Uma vez criada a aplicação acesse o diretório raiz da mesma (no nosso caso a pasta Filmes) e execute o comando:

./script/server

Com este comando você passará a rodar o servidor WEBRick para que você possa testar a sua aplicação. Este é um servidor Ruby capaz de servir um bom número de usuários mas não aconselhável em produção se você espera muitos acessos.

Você pode passar alguns parâmetros para a inicialização do servidor, mas este não é o foco agora e não nos aprofundaremos nisso.

Por padrão, o servidor Rails roda na porta 3000. Para saber se o servidor Rails está rodando acesse no navegador o endereço: localhost:3000. Caso tudo funcione corretamente aparecerá uma página de apresentação do Rails. Caso contrário, modifique a porta no momento de inicializar o servidor e modifique-a também no endereço do navegador.

./script/server -p 3001 no Linux ou ruby script\server -p 3001 no windows

Controller

O que é um controller

explicar o que eh um controller

Criando um Controller

O diretório /script contém um outro utilitário chamado generate que serve para automatizar a criação de várias das estruturas do Rails. Iremos gerar um controller com o nome Filmes, para isso basta digitar o comando:

./script/generate controller Filmes

Se você for no diretório /app/controllers agora, verá que existem dois arquivos no mesmo: application.rb, que é o controller geral do qual todos outros descendem e filmes_controller.rb, que é o que você acabou de criar. Abrindo o arquivo, você verá o seguinte:

class FilmesController <>

Neste momento esse controller não faz absolutamente nada. Se você rodar o servidor Web embutido novamente, apontando para http://localhost:3000/Filmes/, você verá o seguinte:

Observe que o Rails mapeou automaticamente a classe FilmesController? para a URL /filmes, sem que você precise fazer qualquer coisa.

Adicionando Métodos a um Controller

Um controller que não faz nada não tem utilidade, então vamos definir alguma ação a este controler. Inicialmente ele irá imprimir o conhecido "Alô Mundo" na tela. Para isso vamos criar uma método que realize esta operação.

class FilmesController <>   def index
      render_text "Alô Mundo!"
   end
end

O método index é chamado por padrão ao se acessar o controler, caso ele não exista será exibida a página ilustrada na figura 2.

Para se adicionar novas funcionalidades ao controller basta criar novos métodos para o mesmo.

class FilmesController <>   def index
      render_text "Alô Mundo!"
   end

   def teste
      render_text "Testando..."
   end
end

Para testar o novo método criado basta acessar o endereço:

http://localhost:3000/filmes/teste

View?

O que são Views?

escrever um pouco sobre views

Para evitar a necessidade de se escrever código HTML o Rails possui as views, que mapeam ações para apresentação.

Como utilizar as views

Na classe FilmesController?, remova o conteúdo do método index e o método teste deixando o código do controller Filmes assim:

class FilmesController <>   def index

   end
end

Acessando:

http://localhost:3000/filmes/

Você verá a página assim:

 

Isso acontece porque o Rails informa que a view que corresponde àquele método daquele controller não existe. Para remediar isso, crie um novo arquivo em /app/views/filmes chamado index.rhtml, com o seguinte conteúdo:

Olá Mundo!

Recarregando a página você verá o conteúdo do template exibido:

 

Criando Templates para views

Para facilitar ainda mais o trabalho do programador o rails ainda pois um mecanismo de layout que permite o compartilhamento de conteúdo. Para utilizar este mecanismo é muito simples, voltando ao arquivo do controler que criamos (Filmes) colocamos o código:

class FilmesController <>    layout "blank"

   def index
   end

end

Criando agora em app/views/layouts um arquivo chamado blank.rhtml com o conteúdo:

Recarregando a página nós obteremos o seguinte resultado: 

Podemos notar que o Rails processou o arquivo onde definimos o nosso layout (blank) e o arquivo do controller que contém o nosso método, embutindo o resultado do método no layout geral. O atributo @content_for_layout obtém o texto renderizado pelo template da ação e coloca no layout geral.

Utilizando Banco de Dados

O Rails assume três ambientes de execução: test, development e production. O primeiro é usado para executar unit tests na aplicação, verificando se todo o código passa nos testes prescritos. O segundo, que é o padrão, é usado para o desenvolvimento em si. Quando você iniciou o servidor com o comando acima, o ambiente development é que foi carregado. O último ambiente é usado para colocar a aplicação em produção. Cada um deles possui algumas diferenças que facilitam o uso do Rails nesses contextos específicos.

Por causa disso, o Rails normalmente espera que você crie três bancos de dados, um por ambiente.

Então criaremos os três bancos de dados requisitados pelo rails, estes serão:

• Para o ambiente de teste: filmes_test
• Para o ambiente de desenvolvimento: filmes_development
• Para o ambiente de produção: filmes_production

colocar uma explicação de como criar os banco aqui

Agora, vamos configurar o Rails para reconhecer esse banco. Abra o arquivo /config/database.yml. Esse arquivo fornece ao Rails as configurações dos vários bancos usados pelos diferentes ambientes. Um arquivo padrão aparece assim:

development:
  adapter: mysql
  database: Filmes_development
  username: root
  password:
  host: localhost

test:
  adapter: mysql
  database: Filmes_test
  username: root
  password:
  host: localhost

production:
  adapter: mysql
  database: Filmes_production
  username: root
  password:
  host: localhost

Como pode-se notar nós temos uma arquivo no formato YAML onde temos as informações referentes aos três banco utilizados por uma aplicação Rails.

Como no nosso caso estamos utilizando postgresql com um usuário filmes e senha filmes para acessar o banco temos que modificar este arquivo para:

development:
  adapter: postgresql
  database: Filmes_development
  username: filmes
  password: filmes
  host: localhost

test:
  adapter: postgresql
  database: Filmes_test
  username: filmes
  password: filmes
  host: localhost

production:
  adapter: postgresql
  database: Filmes_production
  username: filmes
  password: filmes
  host: localhost

Atenção: Se você estiver rodando o servidor, você precisa reiniciá-lo após modificar a configuração de banco de dados.

O sistema que estamos nos propondo a criar a título ilustrativo ele possui uma usuários que possuem permissão para cadastrar novos filmes no sistema. Então vamos criar inicialmente a tabela de usuários para o nosso sistema.

O script sql para a criação da tabela é:

CREATE TABLE Users (
        id           SERIAL,
        login          VARCHAR(50)  default '' NOT NULL,
        password       VARCHAR(32)  default '' NOT NULL,
        administrator  BOOLEAN DEFAULT 'f' NOT NULL,
        PRIMARY KEY(id)
);

A tabela foi criada com este nome porque o rails mapeia automaticamente siguares em plurais. Este pode ser um ponto fraco do rails pois esta é uma carterística que o deixa depende do inglês.

Toda tabela deve ter uma campo id como chave primária, pois o rails utiliza esta informação para que mesmo???

Você não precisa criar as tabelas no banco da forma tradicional, após falarmos sobre Model veremos como usar o Migration.

Criando Model

Um model é colocar uam descrição do que é um model aqui

Para criar um model basta usar o scrit/generate novamente com os seguintes argumentos:

script/generate model user

Após este comando será criado o arquivo /app/models/user.rb com o seguinte conteúdo:

class User <>

Somente com este código é o que o Rails precisa para mapear a tabela para o código. Por si só, o model já pode ser usado em qualquer local do código. Mas vamos usar um novo controller para exibir esse model. Use o comando generate mais uma vez:

script/generate controller users

Com este comendo foi gerado o arquivo app/controllers/users_controller.rb

contendo o conteúdo:

class UsersController <>

Vamos modificar esse arquivo para utilizar implicitamente o model através de um processo chamado scaffolding. Esse processo cria automaticamente ações do controller para efetuar as operações CRUD (Create, Read, Update, Delete) no banco. O arquivo fica assim:

class UsersController <>    scaffold :user

end

Acessando o endereço:

http://localhost:3000/users

no navegador temos o seguinte resultado: 

Aqui vemos que uma ação para o index foi automaticamente criada e, melhor ainda, já exibindo uma tela com a listagem dos registros (embora ainda nenhum exista na tabela).

Um link também foi incluido para adicionar uma pessoa nova. Clicando no link temos: 

A ação new também é automaticamente criada pelo mecanismo de scaffolding com tudo o que é necessário para a edição de um usuário. Preencha os campos e clique para submeter os dados. A ação create roda e redireciona para a ação list, que é basicamente um sinônimo para a ação index. A tela resultante fica depois de duas inserções é:

 

De forma análoga a anterior iremos realizar todos os procedimento necessários para adicionar as informações referentes aos filmes.

• criando configurando banco de dados
• usar latin1 por enquanto como codificação do banco
• forçar encoding para latin1 nos headers e no HTML

• criando tabela
• scaffold
• reiniciar o servidor (sempre depois de mudar a conf. do banco)
• navegar pela interface do scaffold
• adicionar coluna
• mudar ordem das colunas
• validação : validates_presence_of => :field
• rails não é scaffolding: generate scaffold + alterando index
• partials
• associações: has_many :other; convenção de nome da FK; propriedade adicionada na classe todo.
• herança!
• incluindo coisas (exemplo do blog: comentários)
• XXX.find(params[:id]).yyys.create(
• flash[:notice] = "message"
• redirect

• logs
• testes unitários
• console

Migration - Abistraindo o Banco de Dados

Como foi dito antes, vamos ver agora como criar e alterar tabelas com Migration.

Após aquele comando script/generate model user, foram criados outros arquivos, dentre eles o db/migrate/001_create_users.rb. Esse arquivo define a interface com o banco de dados e a partir dele podemos usar o migrate para gerar ou modificar tabelas. Esse é o formato:

class CreateUsers <>   def self.up
    create_table :users do |t|
      # t.column :name, :string
    end
  end

  def self.down
    drop_table :users
  end
end

Você precisa definir o nome e tipo dos campos da tabela:

class CreateUsers <>   def self.up
    create_table :users do |t|
      t.column :login, :string, :null => false
      t.column :password, :string, :limit => 32, :null => false
      t.column :administrator, :boolean, :default => true
    end
  end

  def self.down
    drop_table :users
  end
end

Com essa definição você pode executar:

rake migrate

Ele irá executar todas as migrations ainda não executadas. O nome da migration deve ser único e o número também único e sequencial.

Saiba mais sobre Migration em http://wiki.rubyonrails.com/rails/pages/UnderstandingMigrations

Referências

• O início deste tutorial foi baseado neste link: http://kb.reflectivesurface.com/br/tutoriais/rubyOnRails/ qualquer semelhança não é mera conhecidência
• Api de rails completa: http://api.rubyonrails.org/

Para saber mais

• http://www.rubyonrails.org
• Tutoriais:
• no site oficial: http://www.rubyonrails.org/docs
• em português:
• http://kb.reflectivesurface.com/br/tutoriais/rubyOnRails/
• http://200.211.78.140/taq/tutorialruby.php

• Vídeo da palestra de David H. Hanson sobre Rails no fisl6.0: http://torrents.softwarelivre.org:6969/stats.html?info_hash=bc8373e84280e61a02212206ec8dd2dfee514966
• rails.vim: http://www.vim.org/scripts/script.php?script_id=1567
• http://wiki.rubyonrails.com/rails/pages/RailsLocalization
• http://www.rails-engines.org/
• http://dev.subimage.com/projects/substruct
• http://railsbrasil.com.br
• Rails para sua Diversão e Lucro. O título é tosco mas é um tutorial muito bom!
• http://blog.invisible.ch/files/rails-reference-1.1.html