Mejores prácticas para volver a utilizar el código entre los controladores en Ruby on Rails

Tengo algunos métodos de control que me gustaría compartir. ¿Cuál es la mejor práctica para hacer esto en ruby ​​on rails? ¿Debo crear una clase abstracta que extiendan mis controladores, o debería crear un módulo y agregarlo a cada controlador? A continuación se muestran los métodos de control que quiero compartir:

def driving_directions @address_to = params[:address_to] @address_from = params[:address_from] @map_center = params[:map_center_start] # if we were not given a center point to start our map on # let's create one. if !@map_center && @address_to @map_center = GeoKit::Geocoders::MultiGeocoder.geocode(@address_to).ll elsif !@map_center && @address_from @map_center = GeoKit::Geocoders::MultiGeocoder.geocode(@address_from).ll end end def printer_friendly starting_point = params[:starting_point].split(',').collect{|e|e.to_f} ne = params[:ne].split(',').collect{|e|e.to_f} sw = params[:sw].split(',').collect{|e|e.to_f} size = params[:size].split(',').collect{|e|e.to_f} address = params[:address] @markers = retrieve_points(ne,sw,size,false) @map = initialize_map([[sw[0],sw[1]],[ne[0],ne[1]]],[starting_point[0],starting_point[1]],false,@markers,true) @address_string = address end 

En mi opinión, se aplican los principios de diseño OO normales:

  • Si el código es realmente un conjunto de utilidades que no necesita acceso al estado del objeto, consideraría ponerlo en un módulo para que se llame por separado. Por ejemplo, si el código es todas las utilidades de mapeo, cree un módulo Maps y acceda a métodos como: Maps::driving_directions .
  • Si el código necesita estado y se usa o podría usarse en cada controlador, coloque el código en ApplicationController.
  • Si el código necesita estado y se usa en un subconjunto de todos los controladores que están cercana y lógicamente relacionados (es decir, todo sobre los mapas), entonces cree una clase base ( class MapController < ApplicationController ) y coloque el código compartido allí.
  • Si el código necesita estado y se usa en un subconjunto de todos los controladores que no están muy relacionados, colóquelo en un módulo e inclúyalo en los controladores necesarios.

En su caso, los métodos necesitan estado ( params ), por lo que la elección depende de la relación lógica entre los controladores que lo necesitan. En adición:

También:

  • Utilice parciales cuando sea posible para código repetido y colóquelos en un directorio común de "parciales" o incluya a través de una ruta específica.
  • Si es posible, mantén un enfoque RESTful (para los métodos) y si crees que estás creando muchos métodos no RESTful, considera extraerlos a su propio controlador.

Sé que esta pregunta fue hecha hace 6 años. Solo quiero señalar que en Rails 4, ahora hay problemas con el controlador que son una solución más inmediata.

De hecho, creo que un módulo es la mejor manera de compartir código entre los controladores. Los ayudantes son buenos si quieres compartir el código entre las vistas. Los ayudantes son básicamente módulos glorificados, por lo que si no necesita acceso de nivel de vista, sugiero colocar un módulo en su carpeta de lib.

Una vez que haya creado el módulo, deberá usar la instrucción include para incluirla en los controladores deseados.

http://www.rubyist.net/~slagell/ruby/modules.html

Estoy de acuerdo con el enfoque del módulo. Cree un archivo Ruby por separado en su directorio lib y coloque el módulo en el nuevo archivo.

La forma más obvia sería agregar los métodos a su ApplicationController, pero estoy seguro de que ya lo sabe.

si desea compartir códigos entre el controlador y los ayudantes, debe intentar crear un módulo en la biblioteca. Puede usar @template y @controller para acceder al método en el controlador y el helper también. Mire esto para más detalles http://www.shanison.com/?p=305

Otra posibilidad:

Si su código común necesita un estado y desea compartir el comportamiento entre los controladores, puede ponerlo en una clase simple de ruby ​​antiguo en su model o directorio lib . Recuerde que las clases model no tienen que ser persistentes aunque todas las clases ActiveRecord sean persistentes. En otras palabras, es aceptable tener clases model transitorias.

Descubrí que una forma efectiva de compartir códigos idénticos entre los controladores es tener un controlador heredado del otro (donde vive el código). Usé este enfoque para compartir métodos idénticos definidos en mis controladores con otro conjunto de controladores de espacio de nombres.