Rails config.aktywa.ustawienie precompile do przetwarzania wszystkich plików CSS i JS w App / assets

config.assets.precompile = ['*.js', '*.css']

, który skompiluje dowolny JavaScript lub CSS w ścieżce zasobu, niezależnie od głębokości katalogu. Znalezione przez Ta odpowiedź .

Drobna zmiana w odpowiedzi techpeace:

config.assets.precompile = ['*.js', '*.css', '**/*.js', '**/*.css']

Dodałbym komentarz do jego odpowiedzi, ale nie mam jeszcze wystarczającej reputacji. Daj mi głos i będę tam!

Uwaga: spowoduje to również prekompilację wszystkich CSS / JavaScript zawartych przez rubygems.

Znalazłem to w kodzie rails:

@assets.precompile               = [ Proc.new{ |path| !File.extname(path).in?(['.js', '.css']) },
                                     /(?:\/|\\|\A)application\.(css|js)$/ ]

Który jest wsparty prowadnicą rails:

Domyślny matcher do kompilacji plików zawiera aplikację.js, podanie.css i wszystkie pliki inne niż JS / CSS

Ta wartość domyślna nie jest resetowana, jeśli używasz +=, więc musisz ją zastąpić = zamiast +=. Zauważ, że najwyraźniej możesz przekazać Proc lub regex do precompile, jak również rozszerzenie. Wierzę, że jeśli chcesz preompilować tylko pliki w górnej level directory, będziesz musiał utworzyć regex w stylu:

config.assets.precompile = [ /\A[^\/\\]+\.(ccs|js)$/i ]

This will get all .css .scss i .js łącznie ze wszystkimi plikami w podkatalogach.

js_prefix    = 'app/assets/javascripts/'
style_prefix = 'app/assets/stylesheets/'

javascripts = Dir["#{js_prefix}**/*.js"].map      { |x| x.gsub(js_prefix,    '') }
css         = Dir["#{style_prefix}**/*.css"].map  { |x| x.gsub(style_prefix, '') }
scss        = Dir["#{style_prefix}**/*.scss"].map { |x| x.gsub(style_prefix, '') }

Rails.application.config.assets.precompile = (javascripts + css + scss)

Chciałem skompilować wszystkie zasoby z /app i / vendor, z wyjątkiem częściowych (których nazwa zaczyna się od podkreślenia_). Oto moja wersja wpisu w aplikacji.rb:

config.assets.precompile << Proc.new { |path|
  if path =~ /\.(css|js)\z/
    full_path = Rails.application.assets.resolve(path).to_path
    app_assets_path = Rails.root.join('app', 'assets').to_path
    vendor_assets_path = Rails.root.join('vendor', 'assets').to_path

    if ((full_path.starts_with? app_assets_path) || (full_path.starts_with? vendor_assets_path)) && (!path.starts_with? '_')
      puts "\t" + full_path.slice(Rails.root.to_path.size..-1)
      true
    else
      false
    end
  else
    false
  end
}

Dodatkowo wyświetla listę plików kompilowanych do celów debugowania...

[[4]}wracam do tego postu w roku 2017.

Nasz produkt nadal mocno korzysta z RoR, nieustannie modyfikujemy nasze konfiguracje precompile dodając Rails.application.config.assets.precompile podczas dodawania nowych modułów. Ostatnio próbowałem zoptymalizować to dodając wzór regex, okazało się, że następujący wzór glob działa:

Rails.application.config.assets.precompile += %w(**/bundle/*.js)

Jednak nadal muszę wykluczyć niektóre moduły, więc starałem się użyć regex zamiast glob.

Dopóki nie zajrzałem do kodu źródłowego sprockets: https://github.com/rails/sprockets-rails/blob/master/lib/sprockets/railtie.rb#L108 , odkryłem, że już używają regex:

app.config.assets.precompile +=
  [LOOSE_APP_ASSETS, /(?:\/|\\|\A)application\.(css|js)$/]

Więc zmieniam mój kod na:

Rails.application.config.assets.precompile +=
  [/^((?!my_excluded_module)\w)*\/bundle\/\w*\.js$/]

Ten fragment zawiera wszystkie pliki JS / css, z wyjątkiem gems , pod: app/ assets, vendor / assets, lib / assets, chyba że są plikami częściowymi (np. " _file.sass"). Ma również strategię włączania zasobów z klejnotów, które nie są zawarte na każdej stronie.

    # These assets are from Gems which aren't included in every page.
    # So they must be included here
    # instead of in the application.js and css manifests.
    config.assets.precompile += %w(a-gem.css a-gem.js b-gem.js)

    # This block includes all js/css files, excluding gems,
    # under: app/assets, vendor/assets, lib/assets
    # unless they are partial files (e.g. "_file.sass")
    config.assets.precompile << Proc.new { |path|
      if path =~ /\.(css|js)\z/
        full_path = Rails.application.assets.resolve(path).to_path
        aps = %w( /app/assets /vendor/assets /lib/assets )
        if aps.any? {|ap| full_path.starts_with?("#{Rails.root}#{ap}")} &&
            !path.starts_with?('_')
          puts "\tIncluding: " + full_path.slice(Rails.root.to_path.size..-1)
          true
        else
          puts "\tExcluding: " + full_path
          false
        end
      else
        false
      end
    }

Chociaż prawdopodobnie nie chciałbyś tego robić, ponieważ prawdopodobnie dwukrotnie kompilujesz zasoby gem (w zasadzie wszystko, co jest już wymagane w Twojej aplikacji.js lub css). Ten fragment zawiera wszystkie pliki JS / css, w tym gems , pod: app/ assets, vendor/assets, lib / assets, chyba że są plikami częściowymi (np. " _file.sass")

# This block includes all js/css files, including gems, 
# under: app/assets, vendor/assets, lib/assets
# and excluding partial files (e.g. "_file.sass")
config.assets.precompile << Proc.new { |path|
  if path =~ /\.(css|js)\z/
    full_path = Rails.application.assets.resolve(path).to_path
    asset_paths = %w( app/assets vendor/assets lib/assets)
    if (asset_paths.any? {|ap| full_path.include? ap}) && 
        !path.starts_with?('_')
      puts "\tIncluding: " + full_path
      true
    else
      puts "\tExcluding: " + full_path
      false
    end
  else
    false
  end
}