Eleganckim rozwiązaniem jest wymaganie controller_name w javascript_include_tag

Zobacz http://apidock.com/rails/ActionController/Metal/controller_name/class

<%= javascript_include_tag "application", controller_name %>

Controller_name.js zostanie załadowany i jest również w zasobie, więc możesz wymagać innych plików stąd.

Przykład, rendering samochodów # index DA

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

//= require wheel
//= require tyre

Zawsze umieszczam to w moich plikach układu. Może skierować Twój js do działania

<%= 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") %>

Twój problem można rozwiązać na różne sposoby.

Dodaj aktywa dynamicznie

Proszę wziąć pod uwagę, że nie jest to dobre rozwiązanie dla trybu produkcyjnego, ponieważ dane Twojego kontrolera nie zostaną wstępnie skompilowane!

1. Dodaj do naszego pomocnika aplikacji następującą metodę:

   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. Wywołanie metody pomocniczej w pliku layout:

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

3. Utwórz określone zasoby dla akcji kontrolera. Np. controller_action.js

Nie zapomnij zmienić YourApp na nazwę aplikacji.

Użycie yield

1. Dodaj <%= yield :head%> do swojego layoutu

2. Dołącz swoje zasoby z Twoich widoków akcji:

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

Aby uzyskać więcej informacji, zobacz prowadnice Rails.

Podoba mi się rozwiązanie albandiguera. Z którym odkryłem, że zasoby javascript / coffeescript nie są indywidualnie wstępnie skompilowane. Co powoduje różnego rodzaju błędy przy użyciu javascript_path. Podzielę się moim rozwiązaniem tego problemu po tym, jak poruszę problem, o którym kilka osób wspomniało w jego komentarzach. Zajmuje się głównie tylko częściowym zestawem kontrolerów nazwanych plikami JavaScript.

Więc zbudowałem Helper aplikacji, aby wykryć, czy plik istnieje w katalogu javascript niezależnie od .kawa/rozszerzenie 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

Ta metoda zwróci pełną ścieżkę do pliku javascript, jeśli istnieje. W przeciwnym razie zwraca zero. Tak więc po komentarzu Pencilcheck możesz dodać tę metodę dla warunkowego include:

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

I teraz masz odpowiednie warunkowe include. A teraz kwestia prekompilowanych aktywów. Ogólnie do optymalizacji nie chcesz wstępnie skompilować aktywów indywidualnie Możesz to jednak zrobić, jeśli musi:

# Live Compilation
config.assets.compile = true

Możesz dodać do swojego pliku konfiguracyjnego środowiska. Najpierw przetestuj go w swoim pliku środowiska programistycznego. Znowu jest to niewłaściwe. Rails asset pipeline wykorzystuje koła zębate do optymalizacji wszystkiego:

Koła łańcuchowe ładują określone pliki, przetwarzają je w razie potrzeby, łączy je w jeden plik, a następnie kompresuje (jeśli Szyny.podanie.config.aktywa.compress jest prawdą). Serwując jeden plik zamiast wielu, Czas ładowania stron można znacznie zmniejszyć ponieważ przeglądarka wysyła mniej żądań. Kompresja zmniejsza również Rozmiar pliku, umożliwiając szybsze pobieranie przez przeglądarkę.

Więcej informacji na temat mechaniki kół zębatych (Asset Pipeline) można znaleźć w dokumentacji http://guides.rubyonrails.org/asset_pipeline.html

Aktywa nie są wstępnie skompilowane indywidualnie. Na przykład gdy próbuję:

<%= javascript_include_tag 'event' %>

Dostaję:

Sprockets::Rails::Helper::AssetFilteredError: Asset filtered out and nie będzie obsługiwany: dodaj Rails.application.config.assets.precompile += %w( event.js ) do config/initializers/assets.rb i uruchom ponownie swój Serwer

Możesz więc dodać, które zasoby mają być wstępnie skompilowane indywidualnie. Musimy tylko dodać odpowiedni kontroler o nazwie pliki javascript w naszym asset initializer. Możemy to zrobić programowo.

Aby uzyskać listę nazw kontrolerów użyję ecoologic ' s example :

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

A teraz, aby uzyskać nazwę wszystkie pliki javascript, które pasują do nazwy bazowej kontrolera, można użyć następującego:

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]}
  }

Wtedy możesz spróbować:

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

To wyświetli listę wszystkich plików javascript, bez ścieżki katalogu, które pasują do nazwy kontrolera. Uwaga Jeśli nazwa kontrolera jest liczbą mnogą, powinna być również nazwa javascript. Zauważ również, że jeśli kontroler jest liczby pojedynczej, a plik javascript jest liczby mnogiej, to nadal będzie go zawierał, ponieważ the_file[a_controller] uda się na częściowym mecz.

Możesz wypróbować to w swoim ustawieniu Rails.application.config.assets.precompile. Wiem, że to daje Ci listę plików poprawnie. Ale zostawię cię, żebyś to przetestował. Daj mi znać, jeśli są jakieś niuanse związane z prekompilacją w ten sposób, ponieważ jestem ciekaw.

Dla bardzo dokładnego wyjaśnienia, jak aktywa precompile zobaczyć ten blog: http://www.sitepoint.com/asset-precompile-works-part/

Niedawno znalazłem proste podejście do korzystania z generowanych skryptów dla określonego kontrolera. Używam do tego rozwiązania gem gon . Dodaj kontroler:

class HomesController < ApplicationController
  before_filter :remember_controller

  private

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

Następnie otwórz homes.js.cofee i dodaj na początku pliku:

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