¿Cómo llamo a los métodos de controlador / vista desde la consola en Rails?

StackOverflow https://stackoverflow.com/questions/151030

  •  02-07-2019
  •  | 
  •  

Pregunta

Cuando cargo script / console , algunas veces quiero jugar con la salida de un controlador o un método de ayuda de vista.

¿Hay formas de:

  • simular una solicitud?
    • ¿
  • llamar métodos desde una instancia de controlador en dicha solicitud?
  • prueba de métodos auxiliares, ya sea a través de dicha instancia de controlador o de otra manera?
¿Fue útil?

Solución

Para llamar a ayudantes, use el objeto ayudante : 

$ ./script/console
>> helper.number_to_currency('123.45')
=> "R$ 123,45"

Si desea utilizar un asistente que no está incluido de manera predeterminada (por ejemplo, porque eliminó helper: all de ApplicationController ), solo incluya el asistente. 

>> include BogusHelper
>> helper.bogus
=> "bogus output"

En cuanto a tratar con controladores , cito Respuesta de Nick : 

> app.get '/posts/1'
> response = app.response
# you now have a rails response object much like the integration tests

> response.body            # get you the HTML
> response.cookies         # hash of the cookies

# etc, etc

Otros consejos

Una manera fácil de llamar a una acción del controlador desde el script / consola y ver / manipular el objeto de respuesta es: 

> app.get '/posts/1'
> response = app.response
# you now have a rails response object much like the integration tests

> response.body            # get you the HTML
> response.cookies         # hash of the cookies

# etc, etc

El objeto de la aplicación es una instancia de ActionController :: Integration :: Session

Esto funciona para mí usando Rails 2.1 y 2.3, no probé versiones anteriores.

Si necesita probar desde la consola (probado en Rails 3.1 y 4.1):

Acciones del controlador de llamadas: 

app.get '/'              
   app.response            
   app.response.headers  # => { "Content-Type"=>"text/html", ... }
   app.response.body     # => "<!DOCTYPE html>\n<html>\n\n<head>\n..."

Métodos de ApplicationController: 

foo = ActionController::Base::ApplicationController.new
foo.public_methods(true||false).sort
foo.some_method

Ayudantes de ruta: 

app.myresource_path     # => "/myresource" 
app.myresource_url      # => "http://www.example.com/myresource"

Ayudantes de visualización: 

foo = ActionView::Base.new

foo.javascript_include_tag 'myscript' #=> "<script src=\"/javascripts/myscript.js\"></script>"

helper.link_to "foo", "bar" #=> "<a href=\"bar\">foo</a>"

ActionController::Base.helpers.image_tag('logo.png')  #=> "<img alt=\"Logo\" src=\"/images/logo.png\" />"

Renderizar: 

views = Rails::Application::Configuration.new(Rails.root).paths["app/views"]
views_helper = ActionView::Base.new views
views_helper.render 'myview/mytemplate'
views_helper.render file: 'myview/_mypartial', locals: {my_var: "display:block;"}
views_helper.assets_prefix  #=> '/assets'

Métodos de ActiveSupport: 

require 'active_support/all'
1.week.ago
=> 2013-08-31 10:07:26 -0300
a = {'a'=>123}
a.symbolize_keys
=> {:a=>123}

Módulos Lib: 

> require 'my_utils'
 => true 
> include MyUtils
 => Object 
> MyUtils.say "hi"
evaluate: hi
 => true

Aquí hay una forma de hacerlo a través de la consola: 

>> foo = ActionView::Base.new
=> #<ActionView::Base:0x2aaab0ac2af8 @assigns_added=nil, @assigns={}, @helpers=#<ActionView::Base::ProxyModule:0x2aaab0ac2a58>, @controller=nil, @view_paths=[]>

>> foo.extend YourHelperModule
=> #<ActionView::Base:0x2aaab0ac2af8 @assigns_added=nil, @assigns={}, @helpers=#<ActionView::Base::ProxyModule:0x2aaab0ac2a58>, @controller=nil, @view_paths=[]>

>> foo.your_helper_method(args)
=> "<html>created by your helper</html>"

Crear una nueva instancia de ActionView :: Base le da acceso a los métodos de visualización normales que su ayudante probablemente usa. Luego, al extender YourHelperModule se mezclan sus métodos en su objeto, lo que le permite ver sus valores de retorno.

Otra forma de hacer esto es usar el depurador de rieles. Hay una guía de Rails sobre depuración en http://guides.rubyonrails.org/debugging_rails_applications.html

Básicamente, inicie el servidor con la opción -u: 

./script/server -u

Y luego inserte un punto de interrupción en su script donde le gustaría tener acceso a los controladores / ayudantes / etc. 

class EventsController < ApplicationController
  def index
    debugger
  end
end

Y cuando realiza una solicitud y pulsa esa parte en el código, la consola del servidor devolverá un mensaje donde podrá realizar solicitudes, ver objetos, etc. desde un símbolo del sistema. Cuando termine, simplemente escriba 'cont' para continuar la ejecución. También hay opciones para la depuración extendida, pero esto al menos debería ayudarlo a comenzar.

Si el método es POST , entonces 

app.post 'controller/action?parameter1=value1&parameter2=value2'

[aquí los parámetros serán según su aplicabilidad]

si no es el método GET , entonces 

app.get 'controller/action'

Aquí se explica cómo realizar una solicitud POST autenticada, utilizando Refinery como ejemplo: 

# Start Rails console
rails console
# Get the login form
app.get '/community_members/sign_in'
# View the session
app.session.to_hash
# Copy the CSRF token "_csrf_token" and place it in the login request.
# Log in from the console to create a session
app.post '/community_members/login', {"authenticity_token"=>"gT7G17RNFaWUDLC6PJGapwHk/OEyYfI1V8yrlg0lHpM=",  "refinery_user[login]"=>'chloe', 'refinery_user[password]'=>'test'}
# View the session to verify CSRF token is the same
app.session.to_hash
# Copy the CSRF token "_csrf_token" and place it in the request. It's best to edit this in Notepad++
app.post '/refinery/blog/posts', {"authenticity_token"=>"gT7G17RNFaWUDLC6PJGapwHk/OEyYfI1V8yrlg0lHpM=", "switch_locale"=>"en", "post"=>{"title"=>"Test", "homepage"=>"0", "featured"=>"0", "magazine"=>"0", "refinery_category_ids"=>["1282"], "body"=>"Tests do a body good.", "custom_teaser"=>"", "draft"=>"0", "tag_list"=>"", "published_at(1i)"=>"2014", "published_at(2i)"=>"5", "published_at(3i)"=>"27", "published_at(4i)"=>"21", "published_at(5i)"=>"20", "custom_url"=>"", "source_url_title"=>"", "source_url"=>"", "user_id"=>"56", "browser_title"=>"", "meta_description"=>""}, "continue_editing"=>"false", "locale"=>:en}

También puede encontrarlos útiles si recibe un error: 

app.cookies.to_hash
app.flash.to_hash
app.response # long, raw, HTML

Puede acceder a sus métodos en Rails Console como siguiendo 

controller.method_name
helper.method_name

En los rieles 3, intente esto: 

session = ActionDispatch::Integration::Session.new(Rails.application)
session.get(url)
body = session.response.body

El cuerpo contendrá el HTML de la url.

Cómo enrutar y renderizar (despacho) de un modelo en Rails 3

Las respuestas anteriores están llamando a ayudantes, pero lo siguiente ayudará a llamar a los métodos del controlador. He usado esto en rails 2.3.2.

primero agregue el siguiente código a su archivo .irbrc (que puede estar en su directorio de inicio) 

class Object
   def request(options = {})
     url=app.url_for(options)
     app.get(url)
     puts app.html_document.root.to_s    
  end
end

luego en la consola de rails puedes escribir algo como ... 

request(:controller => :show, :action => :show_frontpage)

... y el html se descargará en la consola.

Dentro de cualquier acción o vista del controlador, puede invocar la consola llamando al método consola .

Por ejemplo, en un controlador: 

class PostsController < ApplicationController
  def new
    console
    @post = Post.new
  end
end

O en una vista: 

<% console %>

<h2>New Post</h2>

Esto generará una consola dentro de su vista. No necesita preocuparse por la ubicación de la llamada de la consola; no se representará en el momento de su invocación, sino junto a su contenido HTML.

Ver: http://guides.rubyonrails.org/debugging_rails_applications.html

Un posible enfoque para la prueba del método Helper en la consola de rails es

Struct.new(:t).extend(YourHelper).your_method(*arg)

y para recargar y hacer

reload !; Struct.new (: t) .extend (YourHelper) .your_method (* arg)

Para el controlador, puede crear una instancia del objeto controlador en la consola de rails.

Por ejemplo, 

class CustomPagesController < ApplicationController

  def index
    @customs = CustomPage.all
  end

  def get_number
    puts "Got the Number"
  end

  protected

  def get_private_number
    puts 'Got private Number'
  end

end

custom = CustomPagesController.new
2.1.5 :011 > custom = CustomPagesController.new
 => #<CustomPagesController:0xb594f77c @_action_has_layout=true, @_routes=nil, @_headers={"Content-Type"=>"text/html"}, @_status=200, @_request=nil, @_response=nil> 
2.1.5 :014 > custom.get_number
Got the Number
 => nil

# For calling private or protected methods,
2.1.5 :048 > custom.send(:get_private_number)
Got private Number
 => nil

Si ha agregado su propio ayudante y desea que sus métodos estén disponibles en la consola, haga lo siguiente:

  1. en la consola ejecuta incluye YourHelperName
  2. sus métodos de ayuda ahora están disponibles en la consola, úselos llamando a method_name (args) en la consola.

Ejemplo: digamos que tiene MyHelper (con un método my_method ) en 'app / helpers / my_helper.rb`, luego en la consola haga:

  1. incluye MyHelper
  2. my_helper.my_method
Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top