Blog Patrick Espake » helpers

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 estendendo as migrações com helpers

patrickespake — Tue, 24 Mar 2009 13:25:56 +0000

É muito comum termos nas migrações instruções sql para criar chaves estrangeiras e o rails não tem métodos para criar-las.

Por exemplo:

class CreateGameTeams < ActiveRecord::Migration
  def self.up
    create_table :game_teams do |t|
      t.references :team, :null => false
      t.references :game, :null => false
      t.timestamps
    end
 
    execute "ALTER TABLE game_teams ADD CONSTRAINT fk_game_team_teams FOREIGN KEY (team_id) REFERENCES teams (id) ON DELETE CASCADE ON UPDATE
 CASCADE"
    execute "ALTER TABLE game_teams ADD CONSTRAINT fk_game_team_games FOREIGN KEY (game_id) REFERENCES games (id) ON DELETE CASCADE ON UPDATE
 CASCADE"
  end
 
  def self.down
    drop_table :game_teams
  end
end

Para simplificar mais as coisas, é possível criar helpers e estender as funcionalidades das migrações, é isso que será feito para criar um método que gera as chaves estrangeiras (foreign key).

Faça o seguinte:

No diretório lib do projeto crie o arquivo migration_helpers.rb com o conteúdo abaixo:

module MigrationHelpers
 
  def foreign_key(from_table, from_column, to_table)
    constraint_name = "fk_#{from_table}_#{from_column}"
 
    execute %{alter table #{from_table} add constraint #{constraint_name} foreign key (#{from_column}) references #{to_table}(id)}
  end
 
end

Agora é possível adicionar esse método a qualquer migração acrescentando as linhas a seguir no início do arquivo de migração:

require "migration_helpers"
 
class CreateGameTeams < ActiveRecord::Migration
 
  extend MigrationHelpers
 
  def self.up
    create_table :game_teams do |t|
      t.references :team, :null => false
      t.references :game, :null => false
      t.timestamps
    end
 
    foreign_key(:game_teams, :team_id, :teams)
    foreign_key(:game_teams, :game_id, :games)
  end
 
  def self.down
    drop_table :game_teams
  end
end

A linha require coloca a definição do módulo no código de migração e a linha extend adiciona os métodos do módulo MigrationHelpers à migração como métodos de classe.

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: .