Una solución elegante para esto es requerir controller_name en su javascript_include_tag

Véase http://apidock.com/rails/ActionController/Metal/controller_name/class

<%= javascript_include_tag "application", controller_name %>

Nombre del controlador.js se cargará y también está en el activo, por lo que puede requerir otros archivos desde aquí.

Ejemplo, la representación de cars # index dará

<%= javascript_include_tag "application", "cars" %>

Donde los coches.js puede contener

//= require wheel
//= require tyre

Disfrute !

Siempre incluyo esto dentro de mis archivos de diseño. Puede abarcar su js a la acción

<%= javascript_include_tag params[:controller] if AppName::Application.assets.find_asset("#{params[:controller]}.js") %>
<%= javascript_include_tag "#{params[:controller]}_#{params[:action]}"  if AppName::Application.assets.find_asset("#{params[:controller]}_#{params[:action]}.js") %>

Su problema se puede resolver de diferentes maneras.

Agregue los activos dinámicamente

Tenga en cuenta que esta no es una buena solución para el modo de producción, porque los detalles de su controlador no serán precompilados.

1. Agregue a nuestro ayudante de aplicación el siguiente método:

   module ApplicationHelper
       def include_related_asset(asset)
       #          v-----{Change this}
           if !YourApp::Application.assets.find_asset(asset).nil?
               case asset.split('.')[-1]
                   when 'js'
                       javascript_include_tag asset
                   when 'css'
                       stylesheet_link_tag asset
               end
           end
       end
   end
   

2. Llama al método helper en tu layout-file:

   <%= include_related_asset(params[:controller].to_param + '_' + params[:action].to_param . 'js') %>
   

3. Cree activos específicos para las acciones de su controlador. E. g. controller_action.js

Por favor, no olvides cambiar YourApp al nombre de tu app.

Use yield

1. Añade <%= yield :head%> a tu cabeza de diseño

2. Incluye tus activos desde tus vistas de acción:

   <% content_for :head do %>
   <%= javascript_include_tag 'controller_action' %>
   <% end %>
   

Por favor, consulte las guías de Rails para más información.

Me gusta la solución de albandiguer. Con lo cual he encontrado que los activos de javascript/coffeescript no están precompilados individualmente. Lo que causa todo tipo de errores al intentar usar javascript_path. Compartiré mi solución a ese problema después de abordar un problema que algunas personas mencionaron en sus comentarios. Se trata principalmente de un conjunto parcial de controladores llamados archivos JavaScript.

Así que construí un ayudante de aplicación para detectar si el archivo existe en el directorio javascript independientemente de .café/.extensión js:

module ApplicationHelper
  def javascript_asset_path(basename)
    Sprockets::Rails::Helper.assets.paths.select{|i|
      i =~ /javascript/ and i =~ /#{Rails.root}/
    }.each do |directory|
      if Dir.entries(directory).map {|i| i.split('.')[0]}.compact.
          include? basename
        return File.join(directory, basename)
      end
    end
    nil
  end
end

Este método devolverá la ruta completa al archivo javascript si existe. De lo contrario devuelve nil. Por lo tanto, siguiendo el comentario de Pencilcheck, puede agregar este método para un include condicional:

<%= javascript_include_tag(controller_name) if javascript_asset_path(controller_name) %>

Y ahora tienes una inclusión condicional apropiada. Ahora para la cuestión de los activos precompilados. Generalmente para optimización no quieres que los activos sean precompilados individualmente. Sin embargo, puede hacerlo si must:

# Live Compilation
config.assets.compile = true

Puede agregar esto a su archivo de configuración de entorno. Pruébelo en su archivo de entorno de desarrollo primero. Una vez más, esto es desaconsejable. La canalización de activos de Rails utiliza piñones para optimizar todo:

Sprockets carga los archivos especificados, los procesa si es necesario, los concatena en un solo archivo y luego los comprime (si Ferrocarril.aplicación.config.activo.comprimir es cierto). Al servir un archivo en lugar de muchos, el tiempo de carga de las páginas se puede reducir considerablemente porque el navegador hace menos solicitudes. La compresión también reduce tamaño del archivo, lo que permite al navegador descargarlos más rápido.

POR FAVOR, LEA la documentación para obtener más detalles sobre la mecánica de Piñones (Tubería de activos) http://guides.rubyonrails.org/asset_pipeline.html

Los activos no están precompilados individualmente. Por ejemplo cuando intento:

<%= javascript_include_tag 'event' %>

Obtengo:

Sprockets:: Rails:: Helper:: AssetFilteredError: Asset filtered out and no se servirá: agregue Rails.application.config.assets.precompile += %w( event.js ) a config/initializers/assets.rb y reinicie su servidor

Así que puede incluir qué activos se precompilarán individualmente. Solo necesitamos agregar el controlador relevante llamado archivos javascript en nuestro inicializador de activos. Bueno, podemos hacer esto programáticamente.

Para obtener una lista de nombres de controladores usaré el ejemplo de ecoologic :

all_controllers =  Dir[
    Rails.root.join('app/controllers/*_controller.rb')
  ].map { |path|
    path.match(/(\w+)_controller.rb/); $1
  }.compact

Y ahora para obtener el nombre de todos los archivos javascript que coincidan con el nombre base del nombre del controlador puede usar lo siguiente:

javascripts_of_controllers = Sprockets::Rails::Helper.assets.paths.select{|a_path|
    a_path =~ /javascript/ and a_path =~ /#{Rails.root}/
  }.map {|a_path|
    Dir.entries(a_path)
  }.flatten.delete_if {|the_file|
    !the_file['.js']
  }.collect {|the_file|
    the_file if all_controllers.any? {|a_controller| the_file[a_controller]}
  }

Entonces puedes intentar:

# config/initializers/assets.rb
Rails.application.config.assets.precompile += javascripts_of_controllers

Esto le dará una lista de todos los archivos javascript, sin ruta de directorio, que coincidan con el nombre de su controlador. Nota si el nombre del controlador es plural, el nombre de javascript también debería serlo. También tenga en cuenta que si el controlador es singular y el archivo javascript es plural, esto aún lo incluirá porque the_file[a_controller] tendrá éxito en un parcial coincidir.

Siéntase libre de probar esto en su configuración Rails.application.config.assets.precompile. Sé que esto te da la lista de archivos correctamente. Pero te dejaré para que lo pruebes. Déjame saber si hay algún matiz involucrado con la precompilación de esta manera, ya que tengo curiosidad.

Para una explicación muy completa sobre cómo precompilar activos ver este blog: http://www.sitepoint.com/asset-precompile-works-part /

Recientemente encontré un enfoque simple para usar scripts generados para controladores específicos. Utilizo para esa solución gem gon. Añadir en un controlador:

class HomesController < ApplicationController
  before_filter :remember_controller

  private

  def remember_controller
    gon.controller = params[:controller]
  end
end

Después de eso abra su homes.js.cofee y agregue al principio del archivo:

jQuery ->
  if gon.controller == "sermons"
    # Place all functions here...

Eso es todo.