Blog Patrick Espake » helper

Ruby on Rails plugin stylesheet_by_browser

patrickespake — Tue, 04 Aug 2009 01:34:31 +0000

stylesheet_by_browser

Ruby on Rails helper insere o stylesheet de acordo com o navegador.
Desta forma você pode adicionar o css específico para cada navegador, na sua folha de estilo, não necessitando mais fazer hacks em uma única folha de estilo css.

Instalação

Etapa 1

./script/plugin install git://github.com/patrickespake/stylesheet_by_browser.git

Etapa 2

Em seguida, instalar os arquivos necessários no diretório public, executando:

rake stylesheet_by_browser:install

Serão adicionados os arquivos abaixo, no diretório public/stylesheets:

chrome.css
firefox.css
ie.css
opera.css
safari.css

Etapa 3

Por último, adicionar a linha abaixo no elemento HEAD do layout da aplicação:

<%= stylesheet_by_browser %>

Exemplos

<%= stylesheet_by_browser %>

<%= stylesheet_by_browser :media => "all" %>

<%= stylesheet_by_browser :media => "print" %>

<%= stylesheet_by_browser :media => "screen" %>

Documentação

http://lab.patrickespake.com/stylesheet_by_browser

Desinstalação

rake stylesheet_by_browser:uninstall

Código fonte

http://github.com/patrickespake/stylesheet_by_browser/tree/master

Se você gostou desse texto e acha que ajudou você, me recomende: .

Ruby on Rails exemplo de helper para detectar o navegador

patrickespake — Thu, 30 Jul 2009 18:55:10 +0000

Esse é um exemplo simples e sucinto de um helper para detectar o navegador do usuário.

Segue abaixo o código:

module BrowserDetectHelper
  def browser_is? name
    browser_name == name
  end
 
  def browser_name
    ua = request.user_agent.downcase
 
    if ua =~ /firefox\//
      :firefox
    elsif ua =~ /opera\//
      :opera
    elsif ua =~ /chrome\//
      :chrome
    elsif ua =~ /safari\//
      :safari
    elsif ua =~ /msie/
      :ie
    else
      nil
    end
  end
end

Se você gostou desse texto e acha que ajudou você, me recomende: .

Ruby on Rails usando strip_tags nos controllers, models e libs

patrickespake — Mon, 15 Jun 2009 19:46:08 +0000

O Ruby on Rails possui o métogo strip_tags para remover tags html. Esse método está apenas disponível na camada de view, uma vez que faz parte ActionView::Helpers::SanitizeHelper.

Eu não concordo com essa implementação do Rails, acho que deveria ser disponível também na camada de controller e model, onde são os lugares que esse método é mais útil.

Para implementar o strip_tags nos controllers, models e libs, nós podemos adicionar esse método na classe String, desta forma estará disponível em qualquer lugar.

Abra o arquivo config/initializers/new_rails_defaults.rb:

# Be sure to restart your server when you modify this file.
 
# These settings change the behavior of Rails 2 apps and will be defaults
# for Rails 3. You can remove this initializer when Rails 3 is released.
 
if defined?(ActiveRecord)
  # Include Active Record class name as root for JSON serialized output.
  ActiveRecord::Base.include_root_in_json = true
 
  # Store the full class name (including module namespace) in STI type column.
  ActiveRecord::Base.store_full_sti_class = true
end
 
# Use ISO 8601 format for JSON serialized times and dates.
ActiveSupport.use_standard_json_time_format = true
 
# Don't escape HTML entities in JSON, leave that for the #json_escape helper.
# if you're including raw json in an HTML page.
ActiveSupport.escape_html_entities_in_json = false

Adicione no final do arquivo as linhas:

class String
  def strip_tags
    ActionController::Base.helpers.strip_tags(self)
  end
end

As linhas acima criam o método strip_tags na classe String.

Ficando o arquivo completo assim:

# Be sure to restart your server when you modify this file.
 
# These settings change the behavior of Rails 2 apps and will be defaults
# for Rails 3. You can remove this initializer when Rails 3 is released.
 
if defined?(ActiveRecord)
  # Include Active Record class name as root for JSON serialized output.
  ActiveRecord::Base.include_root_in_json = true
 
  # Store the full class name (including module namespace) in STI type column.
  ActiveRecord::Base.store_full_sti_class = true
end
 
# Use ISO 8601 format for JSON serialized times and dates.
ActiveSupport.use_standard_json_time_format = true
 
# Don't escape HTML entities in JSON, leave that for the #json_escape helper.
# if you're including raw json in an HTML page.
ActiveSupport.escape_html_entities_in_json = false
 
class String
  def strip_tags
    ActionController::Base.helpers.strip_tags(self)
  end
end

Agora reinicie o seu servidor web para pegar essas novas configurações na inicialização da aplicação.

Agora quando você precisar do strip_tags pode usar assim, exemplos:

params['title'] = params['title'].strip_tags
 
ou
 
>> 'meu texto'.strip_tags
=> "meu texto"

Se você gostou desse texto e acha que ajudou você, me recomende: .

Ruby on Rails usando o jQuery ao invés do Prototype

patrickespake — Tue, 09 Jun 2009 21:42:19 +0000

Eu gosto mais do jQuery acho ele mais leve, mais funcional e com efeitos melhores.

Vou mostrar como substituir o Prototype e colocar o jQuery no seu lugar.

Instalação do plugin jRails:

ruby script/plugin install http://ennerchi.googlecode.com/svn/trunk/plugins/jrails

No layout da sua aplicação remova o uso do Prototype, remova a linha abaixo, caso ela exista:

<%= javascript_include_tag :defaults %>

Agora adicionei as bibliotecas javascripts entre as tags heads:

...
  
    ...
    <%= javascript_include_tag "jquery" %>
    <%= javascript_include_tag "jquery-ui" %>
    <%= javascript_include_tag "jrails" %>
  
...

Pronto! Fazendo isso o jQuery está disponível e compatível com o Ruby on Rails, ou seja, todos os helpers javascript usarão agora o jQuery como framework javascript.

O plugin jRails sobrescreve os helpers javascript para usar o jQuery.

Se você gostou desse texto e acha que ajudou você, me recomende: .

Ruby on Rails usando o helper Cycle de uma forma mais apurada

patrickespake — Tue, 09 Jun 2009 19:36:47 +0000

O helper cycle é legal para trabalhar com alternância de classes css em linhas de uma tabela, divs, listas e outros elementos html. Quando você deseja que as linhas pares fiquem de uma cor e as linhas ímpares fiquem de outra cor.

Por exemplo:


 
  
 
  <%if@message.photos.size>0%><%for photo in@message.photos%><%= cycle('even', 'odd')%>">
          <%end%><%else%><%end%>
  Photos
    
      Photo
      Description
      Actions
    
  

        
         
         <%= image_tag photo.file.url(:thumb) %>
          <%= photo.description %>
          
            <%= link_to_delete message_photo_path(@message, photo) %>
          
        
        
      
      
        No photos.

E você pode ter uma regra css da seguinte forma:

table.media-table tr.even {
}
 
table.media-table tr.odd {
  background-color: #e5eefa;
}

Desta forma todas as linhas ímpares ficaram de uma cor diferente.

É um helper bem simples que permite deixar suas tabelas, divs, listas e outros itens htmls bem legíveis através de regras css adequadas.

Você pode encontrar um problema de estilização quando usar o helper cycle em duas tabelas distintas conforme exemplo:


 
  
 
  <%if@message.photos.size>0%><%for photo in@message.photos%><%= cycle('even', 'odd')%>">
          <%end%><%else%><%end%>
  Photos
    
      Photo
      Description
      Actions
    
  

        
         
         < %= image_tag photo.file.url(:thumb) %>
          < %= photo.description %>
          
            <%= link_to_delete message_photo_path(@message, photo) %>
          
        
        
      
      
        No photos.
      
      
  

 




 

 
  
 
  <%if@message.videos.size>0%><%for video in@message.videos%><%= cycle('even', 'odd')%>">
          <%end%><%else%><%end%>
  Videos
    
      Video
      Description
      Actions
    
  

         
         
         <%= video.file.url %>
          <%= video.description %>
          <%= link_to_delete message_video_path(@message, video) %>
        
        
      
      
        No videos.

No exemplo acima nós temos duas tabelas, uma para as fotos e outra para os vídeos. Nessa situação pode acontecer da próxima linha da tabela de vídeos ser pintada com a regra css odd, caso o número de linhas da tabela de fotos seja par.

Isso acontece por que o helper cycle não zera o seu contador entre um uso e outro.

Para trabalhar adequadamente você pode dar um nome para cada uso do helper cycle, desta forma:

...
<%= cycle('even', 'odd', 'row_photos') %>
...
<%= cycle('even', 'odd', 'row_videos') %>
...

Fazendo isso cada uso do helper cycle terá o seu próprio contador, e o problema de pintar o cabeçalho da tabela não ocorre mais.

Existe uma outra opção, você pode usar o helper cycle como mencionado no primeiro exemplo, sem definir um nome para cada uso do helper cycle, entre um uso e outro do helper cycle você pode pedir para zerar o seu contador, chamando o helper reset_cycle, exemplo:

...
<%= cycle('even', 'odd') %>
...
<% reset_cycle %>
...
<%= cycle('even', 'odd') %>
...

O helper reset_cycle também aceita zerar apenas um determinado helper cycle, basta informar o nome que você deseja zerar:

1	<% reset_cycle("row_photos") %>

Se você gostou desse texto e acha que ajudou você, me recomende: .

Ruby on Rails time_ago_in_words

patrickespake — Fri, 05 Jun 2009 19:04:33 +0000

Gosto muito de algumas coisas simples do Rails, o helper time_ago_in_words é uma delas, serve para escrever a quanto tempo ocorreu a partir da data atual.

Por exemplo:

1
2
3

time_ago_in_words(3.minutes.from_now)       # => 3 minutes
time_ago_in_words(Time.now - 15.hours)      # => 15 hours
time_ago_in_words(Time.now)                 # => less than a minute

Outro exemplo:


   
    <%= draft.title %>
    <%= time_ago_in_words(draft.updated_at) %> ago

Se você gostou desse texto e acha que ajudou você, me recomende: .

Ruby on Rails como fazer dois atributos da mesma classe apontarem para a mesma classe pai no ActiveRecord

patrickespake — Mon, 23 Mar 2009 19:20:25 +0000

Hoje estava programando um sistema de menus, onde cada item de menu pode ter vários outros itens, não existindo limite de subníveis.

Para conseguir obter essa relação e associação no banco de dados criei dois models BackendMenu e BackendMenuNode, com as seguintes migrações:

BackendMenu:

class CreateBackendMenus < ActiveRecord::Migration
  def self.up
    create_table :backend_menus do |t|
      t.string  :title,     :null => false
      t.string  :path,      :null => false
      t.integer :weight,    :null => false, :default => 0
      t.boolean :is_active, :null => false, :default => false
      t.boolean :is_root,   :null => false, :default => false
      t.timestamps
    end
  end
 
  def self.down
    drop_table :backend_menus
  end
end

BackendMenuNode:

class CreateBackendMenuNodes < ActiveRecord::Migration
  def self.up
    create_table :backend_menu_nodes do |t|
      t.integer :root_id, :null => false
      t.integer :node_id, :null => false
      t.integer :weight,  :null => false, :default => 0
    end
 
    add_index(:backend_menu_nodes, [:root_id, :node_id], :unique => true)
    execute "ALTER TABLE backend_menu_nodes ADD CONSTRAINT fk_backend_menu_nodes_backend_menus_root FOREIGN KEY (root_id) REFERENCES backend_menus (id) ON DELETE CASCADE ON UPDATE CASCADE"
    execute "ALTER TABLE backend_menu_nodes ADD CONSTRAINT fk_backend_menu_nodes_backend_menus_node FOREIGN KEY (node_id) REFERENCES backend_menus (id) ON DELETE CASCADE ON UPDATE CASCADE"
  end
 
  def self.down
    drop_table :backend_menu_nodes
  end
end

Todos os itens de menu vão ficar cadastrados na tabela backend_menus e associação para descobrir os menus filhos será feito pela tabela backend_menu_nodes. A tabela backend_menu_nodes tem as colunas root_id que se referência ao pai e a coluna node_id que se referência aos menus filhos, desta forma um menu pode ter N itens.

Tanto a coluna root_id e node_id fazem referência a tabela backend_menus.

Para conseguir obter essa associação no ActiveRecord fiz o seguinte:

BackendMenu:

class BackendMenu < ActiveRecord::Base
  # associações
  has_many :nodes, :class_name => "BackendMenuNode", :foreign_key => "root_id"
  ...
end

BackendMenuNode:

class BackendMenuNode < ActiveRecord::Base
  # associações
  belongs_to :root, :class_name => "BackendMenu", :foreign_key => "root_id"
  belongs_to :node, :class_name => "BackendMenu", :foreign_key => "node_id"
  ...
end

Fazendo a relação acima eu consigo navegar pelo menu pai e os meus filhos.

Para imprimir o menu eu criei 3 helpers usando a recursividade:

module BackendHelper
 
  # cria o menu do backend
  def menu(collection, class_name = "menu")
    content = content_tag :ul, :class => class_name do
      menu_items(collection)
    end
    content
  end
 
  # cria os items do menu
  def menu_items(collection)
    content = ""
    for item in collection
      if item.instance_of? BackendMenu
        content << item_nodes(item)
      else
        content << item_nodes(item.node)
      end
    end
    content
  end
 
  # cria os nós do item de menu
  def item_nodes(item)
    content = ""
    class_name = "leaf"
 
    if item.nodes.size > 0
      class_name = "collapsed"
      content << content_tag(:li, :class => class_name) do
        link_to(item.title, item.path) + menu(item.nodes, "menu hide")
      end
    else
      content << content_tag(:li, link_to(item.title, item.path), :class => class_name)
    end
    content
  end
 
end

No controlador eu faço o seguinte:

1	@backend_menus = BackendMenu.find :all, :conditions => { :is_root => true }, :order => 'weight'

Na view:



  <%= menu(@backend_menus) %>

Se você quiser alguns menus de teste, usei a migração abaixo:

class AddBackendMenus < ActiveRecord::Migration
  def self.up
    BackendMenu.delete_all
 
    # criação dos menus pais
    BackendMenu.create(:title => 'Principal',
      :path => 'principal',
      :weight => 1,
      :is_active => true,
      :is_root => true)
 
    BackendMenu.create(:title => 'Criar Conteúdo',
      :path => 'criar-conteudo',
      :weight => 2,
      :is_active => true,
      :is_root => true)
 
    BackendMenu.create(:title => 'Gerenciamento de Conteúdo',
      :path => 'gerenciamento-de-conteudo',
      :weight => 3,
      :is_active => true,
      :is_root => true)
 
    BackendMenu.create(:title => 'Site Construtor',
      :path => 'site-construtor',
      :weight => 4,
      :is_active => true,
      :is_root => true)
 
    BackendMenu.create(:title => 'Site Configuração',
      :path => 'site-configuracao',
      :weight => 5,
      :is_active => true,
      :is_root => true)
 
    BackendMenu.create(:title => 'Gerenciamento de Usuário',
      :path => 'gerenciamento-de-usuario',
      :weight => 6,
      :is_active => true,
      :is_root => true)
 
    BackendMenu.create(:title => 'Relatórios',
      :path => 'relatorios',
      :weight => 7,
      :is_active => true,
      :is_root => true)
 
    BackendMenu.create(:title => 'Ajuda',
      :path => 'ajuda',
      :weight => 8,
      :is_active => true,
      :is_root => true)
 
    # criação dos menus filhos
    BackendMenu.create(:title => 'Página',
      :path => 'criar-conteudo/pagina',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('criar-conteudo').id,
      :node_id => BackendMenu.find_by_path('criar-conteudo/pagina').id,
      :weight => 1)
 
    BackendMenu.create(:title => 'História',
      :path => 'criar-conteudo/historia',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('criar-conteudo').id,
      :node_id => BackendMenu.find_by_path('criar-conteudo/historia').id,
      :weight => 2)
 
    BackendMenu.create(:title => 'Comentários',
      :path => 'gerenciamento-de-conteudo/comentarios',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('gerenciamento-de-conteudo').id,
      :node_id => BackendMenu.find_by_path('gerenciamento-de-conteudo/comentarios').id,
      :weight => 1)
 
    BackendMenu.create(:title => 'Ativos',
      :path => 'gerenciamento-de-conteudo/comentarios/ativos',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('gerenciamento-de-conteudo/comentarios').id,
      :node_id => BackendMenu.find_by_path('gerenciamento-de-conteudo/comentarios/ativos').id,
      :weight => 1)
 
    BackendMenu.create(:title => 'Teste',
      :path => 'gerenciamento-de-conteudo/comentarios/ativos/teste',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('gerenciamento-de-conteudo/comentarios/ativos').id,
      :node_id => BackendMenu.find_by_path('gerenciamento-de-conteudo/comentarios/ativos/teste').id,
      :weight => 1)
 
    BackendMenu.create(:title => 'Inativos',
      :path => 'gerenciamento-de-conteudo/comentarios/inativos',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('gerenciamento-de-conteudo/comentarios').id,
      :node_id => BackendMenu.find_by_path('gerenciamento-de-conteudo/comentarios/inativos').id,
      :weight => 2)
 
    BackendMenu.create(:title => 'Conteúdo',
      :path => 'gerenciamento-de-conteudo/conteudo',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('gerenciamento-de-conteudo').id,
      :node_id => BackendMenu.find_by_path('gerenciamento-de-conteudo/conteudo').id,
      :weight => 2)
 
    BackendMenu.create(:title => 'Tipos de Conteúdo',
      :path => 'gerenciamento-de-conteudo/tipos-de-conteudo',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('gerenciamento-de-conteudo').id,
      :node_id => BackendMenu.find_by_path('gerenciamento-de-conteudo/tipos-de-conteudo').id,
      :weight => 3)
 
    BackendMenu.create(:title => 'Publicação de RSS',
      :path => 'gerenciamento-de-conteudo/publicacao-de-rss',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('gerenciamento-de-conteudo').id,
      :node_id => BackendMenu.find_by_path('gerenciamento-de-conteudo/publicacao-de-rss').id,
      :weight => 4)
 
    BackendMenu.create(:title => 'Blocos',
      :path => 'site-construtor/blocos',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('site-construtor').id,
      :node_id => BackendMenu.find_by_path('site-construtor/blocos').id,
      :weight => 1)
 
    BackendMenu.create(:title => 'Formulários',
      :path => 'site-construtor/formularios',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('site-construtor').id,
      :node_id => BackendMenu.find_by_path('site-construtor/formularios').id,
      :weight => 2)
 
    BackendMenu.create(:title => 'Menus',
      :path => 'site-construtor/menus',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('site-construtor').id,
      :node_id => BackendMenu.find_by_path('site-construtor/menus').id,
      :weight => 3)
 
    BackendMenu.create(:title => 'Módulos',
      :path => 'site-construtor/modulos',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('site-construtor').id,
      :node_id => BackendMenu.find_by_path('site-construtor/modulos').id,
      :weight => 4)
 
    BackendMenu.create(:title => 'temas',
      :path => 'site-construtor/temas',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('site-construtor').id,
      :node_id => BackendMenu.find_by_path('site-construtor/temas').id,
      :weight => 5)
 
    BackendMenu.create(:title => 'Tradução',
      :path => 'site-construtor/traducao',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('site-construtor').id,
      :node_id => BackendMenu.find_by_path('site-construtor/traducao').id,
      :weight => 6)
 
    BackendMenu.create(:title => 'Idiomas',
      :path => 'site-configuracao/idiomas',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('site-configuracao').id,
      :node_id => BackendMenu.find_by_path('site-configuracao/idiomas').id,
      :weight => 1)
 
    BackendMenu.create(:title => 'Logs e Alertas',
      :path => 'site-configuracao/logs-e-alertas',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('site-configuracao').id,
      :node_id => BackendMenu.find_by_path('site-configuracao/logs-e-alertas').id,
      :weight => 2)
 
    BackendMenu.create(:title => 'Manutenção do Site',
      :path => 'site-configuracao/manuencao-do-site',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('site-configuracao').id,
      :node_id => BackendMenu.find_by_path('site-configuracao/manuencao-do-site').id,
      :weight => 3)
 
    BackendMenu.create(:title => 'Ações',
      :path => 'site-configuracao/acoes',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('site-configuracao').id,
      :node_id => BackendMenu.find_by_path('site-configuracao/acoes').id,
      :weight => 4)
 
    BackendMenu.create(:title => 'Regras de Acesso',
      :path => 'gerenciamento-de-usuario/regras-de-acesso',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('gerenciamento-de-usuario').id,
      :node_id => BackendMenu.find_by_path('gerenciamento-de-usuario/regras-de-acesso').id,
      :weight => 1)
 
    BackendMenu.create(:title => 'Permissões',
      :path => 'gerenciamento-de-usuario/permissoes',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('gerenciamento-de-usuario').id,
      :node_id => BackendMenu.find_by_path('gerenciamento-de-usuario/permissoes').id,
      :weight => 2)
 
    BackendMenu.create(:title => 'Regras',
      :path => 'gerenciamento-de-usuario/regras',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('gerenciamento-de-usuario').id,
      :node_id => BackendMenu.find_by_path('gerenciamento-de-usuario/regras').id,
      :weight => 3)
 
    BackendMenu.create(:title => 'Configurações de Usuários',
      :path => 'gerenciamento-de-usuario/configuracoes-de-usuarios',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('gerenciamento-de-usuario').id,
      :node_id => BackendMenu.find_by_path('gerenciamento-de-usuario/configuracoes-de-usuarios').id,
      :weight => 4)
 
    BackendMenu.create(:title => 'Usuários',
      :path => 'gerenciamento-de-usuario/usuarios',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('gerenciamento-de-usuario').id,
      :node_id => BackendMenu.find_by_path('gerenciamento-de-usuario/usuarios').id,
      :weight => 5)
 
    BackendMenu.create(:title => 'Entrada de Logs',
      :path => 'relatorios/entrada-de-logs',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('relatorios').id,
      :node_id => BackendMenu.find_by_path('relatorios/entrada-de-logs').id,
      :weight => 1)
 
    BackendMenu.create(:title => 'Erros de Acesso Negado',
      :path => 'relatorios/erros-de-acesso-negado',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('relatorios').id,
      :node_id => BackendMenu.find_by_path('relatorios/erros-de-acesso-negado').id,
      :weight => 2)
 
    BackendMenu.create(:title => 'Status',
      :path => 'relatorios/status',
      :is_active => true,
      :is_root => false)
    BackendMenuNode.create(:root_id => BackendMenu.find_by_path('relatorios').id,
      :node_id => BackendMenu.find_by_path('relatorios/status').id,
      :weight => 3)
  end
 
  def self.down
    BackendMenu.delete_all
  end
end

Se você gostou desse texto e acha que ajudou você, me recomende: .

Ruby on Rails uma forma mais inteligente de organizar controladores e helpers

patrickespake — Wed, 18 Mar 2009 20:47:38 +0000

Estou trabalhando numa nova aplicação em Rails, ela é dividida em área administrativa e uma área vísivel a todos os visitantes da aplicação.

Inicialmente eu comecei com os controladores admin_controller.erb, home_controller.erb e o controlador padrão application_controller.erb, que é herdado pelos dois primeiros controladores.

application_controller.erb

# Filters added to this controller apply to all controllers in the application.
# Likewise, all the methods added will be available for all controllers.
 
class ApplicationController < ActionController::Base
  helper :all # include all helpers, all the time
  protect_from_forgery # See ActionController::RequestForgeryProtection for details
 
  # Scrub sensitive parameters from your log
  # filter_parameter_logging :password
end

admin_controller.erb

class AdminController < ApplicationController
 
  def index
  end
 
end

home_controller.erb

class HomeController < ApplicationController
 
  def index
  end
 
end

Mas eu quero deixar a minha aplicação mais simples e inteligente, a minha área administrativa vai ser grande, bem como o meu frontend.

Vão existir uma série de filtros e helpers que vão ser usados em comum por todos os diversos controladores da área administrativa e do frontend, do jeito que está hoje eu teria que colocar muito código no application_controller.erb, bem como no helper padrão application_helper.erb.

Desta forma eu decidi criar dois novos controladores backend_controller.erb e frontend_controller.erb, a minha ideia é fazer todos os controladores da área administrativa herdarem o backend_controller.erb, e todos os controladores do meu frontend herdarem o controlador frontend_controller.erb. Por sua vez os controladores backend_controller.erb e frontend_controller.erb herdarão o application_controller.erb, o que garante que a minha aplicação vai continuar funcionando corretamente.

Fazendo isso eu ganho um grau maior de componentização dos controladores, quando eu adicionar um filtro, método ou helper no backend_controller.erb ou frontend_controller.erb todos os controladores filhos deles já terão essa funcionalidade disponível.

Seguindo essa ideia eu fiz algumas alterações para implementar esse recurso:

Criei dois novos controladores:

backend_controller.erb

# Filtros adicionados nesse controlador serão aplicados em todos os controladores filhos
# De igual modo, todos os métodos adicionados estarão disponíveis para todos os controladores filhos
 
class BackendController < ApplicationController
end

frontend_controller.erb

# Filtros adicionados nesse controlador serão aplicados em todos os controladores filhos
# De igual modo, todos os métodos adicionados estarão disponíveis para todos os controladores filhos
 
class FrontendController < ApplicationController
end

Alterei os controladores abaixo, para herdarem os controladores criados acimas:

admin_controller.erb

class AdminController < BackendController
 
  def index
  end
 
end

home_controller.erb

class HomeController < FrontendController
 
  def index
  end
 
end

Fazendo isso eu consigo ganhar uma componentização muito grande, se eu adicionar alguma coisa no controlador application_controller.erb, ele está disponível tanto no admin como no frontend.

Adicionando algo no frontend_controller.erb estará disponível em todo o frontend e adicionando algo no backend_controller.erb estará disponível em todo o admin.

É possível melhorar mais ainda, vamos criar dois novos helpers:

backend_helper.rb

1 2	module BackendHelper end

frontend_helper.rb

1 2	module FrontendHelper end

Vou colocar esses helpers para serem carregados em todos os controladores que herdam backend_controller.rb e frontend_controller.erb:

backend_controller.rb

# Filtros adicionados nesse controlador serão aplicados em todos os controladores filhos
# De igual modo, todos os métodos adicionados estarão disponíveis para todos os controladores filhos
 
class BackendController < ApplicationController
  layout "admin"
  helper :backend
end

Acima eu aproveitei e adicionei o layout “admin.html.erb”, que será usado por todos as views da área administrativa.

frontend_controller.rb

# Filtros adicionados nesse controlador serão aplicados em todos os controladores filhos
# De igual modo, todos os métodos adicionados estarão disponíveis para todos os controladores filhos
 
class FrontendController < ApplicationController
  helper :frontend
end

Agora no application_controller.erb, comente a linha helper :all, para não carregar todos os helpers, só os que você precisa.

# Filters added to this controller apply to all controllers in the application.
# Likewise, all the methods added will be available for all controllers.
 
class ApplicationController < ActionController::Base
  # helper :all # include all helpers, all the time
  protect_from_forgery # See ActionController::RequestForgeryProtection for details
 
  # Scrub sensitive parameters from your log
  # filter_parameter_logging :password
end

Pronto! ;-)

Se você gostou desse texto e acha que ajudou você, me recomende: .

Ruby on Rails 2.2 Como Criar Rss Feed

patrickespake — Sat, 07 Feb 2009 19:24:37 +0000

Hoje vou mostrar como criar Rss Feed no Ruby on Rails 2.2, no final você vai dar risada, de tão simples que é. Vamos lá!

Geralmente a action index é responsável por fazer a listagem das informações, ela pode ser parecer com isso:

1
2
3

def index
  @histories = History.find :all, :limit => 10
end

ou como abaixo, quando você está usando o plugin will_paginate:

1
2
3

def index
  @histories = History.paginate :all, :page => params[:page]
end

Não vamos precisar mexer em nada na action index.

Você precisa criar um novo template chamado index.rss.builder, que deve estar localizado em app/views/histories/index.rss.builder com o seguinte conteúdo:

xml.instruct! 'xml', :version => "1.0"
xml.rss :version => "2.0" do
  xml.channel do
    xml.title "Notícias"
    xml.description "Últimas Notícias"
    xml.language('pt-BR')
    xml.link formatted_histories_url(:rss)
 
    for history in @histories
      xml.item do
        xml.title history.title
        xml.description history.content
        xml.pubDate history.created_at.to_s(:rfc822)
        xml.link history_url(history)
        xml.guid history_url(history)
      end
    end
  end
end

Pronto! O que você não acredita que está pronto? É verdade falta adicionar o link no template index.html.erb para ver o Rss Feed.

No template index.html.erb adicione:

1	<%= link_to " RSS Feed", formatted_histories_url(:rss) %>

Para acessar o Rss Feed visite: http://localhost:3000/histories.rss.

Não esqueça de definir no seu arquivo config/routes.rb que o model history trabalha com urls RESTful:

1	map.resources :histories

Uhmm! Não estou feliz ainda, acho que dá para melhorar mais, é verdade podemos adicionar:

Entre as tags:

...

do HTML, fazendo isso o navegador adiciona o ícone de Feed na barra de endereço e deixa a coisa mais intuitiva para o usuário.

Vamos fazer isso de uma forma mais elegante e dinâmica.

No layout da sua aplicação adicionei yield :auto_discovery entre as tags head do HTML:


...
  <%= yield :auto_discovery %>
...

Agora no template index.html.erb adicione:

1
2
3

<% content_for :auto_discovery do %>
  <%= auto_discovery_link_tag(:rss, :action => :index, :format => :rss) %>
<% end %>

Agora sim ficou legal! ;-)

Mais informações assista aqui: http://media.railscasts.com/videos/087_generating_rss.mov.

Se você gostou desse texto e acha que ajudou você, me recomende: .

Ruby on Rails helper para criar o Mapa do Site

patrickespake — Fri, 06 Feb 2009 20:22:38 +0000

Hoje eu precisei criar o “Mapa do Site”, conforme imagem acima, procurei por alguns plugins para fazer isso, mas infelizmente não encontrei nada da forma que eu queria, então resolvi implementar o meu próprio helper.

Através das tags htmls ul e li é possível gerar essa estrutura.

Para implementar essa funcionalidade eu desenvolvi o seguinte helper:

module SitemapHelper
 
  def sitemap
    map =
    {
      link_to("Página Inicial", root_url) =>
        {
          "Informação" => [link_to("Notícias", histories_path), link_to("Newsletters", newsletters_path)],
          "Capacitação e Aperfeiçoamento" => [link_to("Serviços", services_path), link_to("Institucionais", institutionals_path), link_to("Eventos", events_path), link_to("Melhores Práticas", best_practices_path), link_to("Podcasts", podcasts_path), link_to("Tvs", tvs_path), link_to("Degustações", tastings_path)],
          "Editora" => [link_to("Produtos", products_path)],
          link_to("Grupo", groups_path) => nil
        }
    }
 
    content_tag(:ul, generate_map(map))
  end
 
  def generate_map(elements)
    html = ''
 
    elements.each do |key, value|
      html << content_tag(:li, key)
 
      if !value.nil? and value.length > 0
        html << content_tag(:ul, generate_map(value.sort))
      end
    end
 
    return html
  end
 
end

No código acima eu criei um método chamado sitemap, dentro desse método existe um hash chamado map, nesse hash eu defino a hierarquia dos links.

O outro método é o generate_map, ele é responsável por gerar a estrutura html em listas através das tags html ul e li. Esse método usa recursividade (o grande amigo dos programadores ;-)).

Feito tudo isso, agora no template eu só chamo o helper, por exemplo no index.html.erb:

1	<%= sitemap %>

É possível chamar esse helper nos templates de erro 404, assim melhora a navegação para o usuário.

Se você gostou desse texto e acha que ajudou você, me recomende: .