ruby on rails - present - Ajustes Rails config.assets.precompile para procesar todos los archivos CSS y JS en aplicaciones/activos

sprockets rails

Question

Deseo precompilar todos los archivos CSS y JS en la carpeta de la app/assets mi proyecto. NO quiero precompilar todo en proveedor / activos o lib / activos, solo las dependencias de mis archivos según sea necesario.

Probé la siguiente configuración de comodín, pero precompila incorrectamente todo. Esto da como resultado mucho trabajo adicional e incluso causa una falla de compilación cuando se usa bootstrap-sass.

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

¿Cuál es mi mejor opción para procesar solo mis archivos en app/assets ? ¡Gracias!

Answer 1

Encontré esto en el código de los rieles:

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

Que se respalda con la guía de rieles:

El comparador predeterminado para compilar archivos incluye application.js, application.css y todos los archivos que no son JS / CSS

Este valor predeterminado no se restablece si usa += , por lo que debe anularlo con a = lugar de += . Tenga en cuenta que, al parecer, puede pasar un Proc o una expresión regular para precompile , así como una extensión. Creo que si quieres precompilar solo archivos en el directorio de nivel superior, tendrás que crear una expresión regular como:

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

Answer 2

Esta tarea se vuelve más difícil por el hecho de que los piñones funcionan con rutas lógicas que no incluyen dónde se encuentran los recursos subyacentes sin compilar.

Supongamos que mi proyecto tiene el archivo JS "/app/assets/javascripts/foo/bar.js.coffee".

El compilador de piñones primero determinará la extensión del archivo de salida, en este caso ".js", y luego evaluará si compila o no la ruta lógica "foo / bar.js". El recurso no compilado podría estar en "app / assets / javascripts", "vendor / assets / javascripts", "lib / assets / javascripts" o una gema, por lo que no hay forma de incluir / excluir un archivo particular basado en la ruta lógica solo.

Para determinar dónde se encuentra el recurso subyacente, creo que es necesario preguntar al entorno de piñones (disponible a través del objeto Rails.application.assets) para resolver la ruta real del recurso dada la ruta lógica.

Aquí está la solución que estoy usando. Soy bastante nuevo para Ruby, así que este no es el código más elegante:

# In production.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
if full_path.starts_with? app_assets_path
puts "including asset: " + full_path
true
else
puts "excluding asset: " + full_path
false
end
else
false
end
}

Con piñones> 3.0, esto no funcionará en producción porque Rails.application.assets será nil (asumiendo default: config.assets.compile = false).

Para solucionarlo, reemplace la asignación full_path por:

@assets ||= Rails.application.assets || Sprockets::Railtie.build_environment(Rails.application)
full_path = @assets.resolve(path)

Ver también: https://github.com/rails/sprockets-rails/issues/237

Answer 3

Este fragmento incluye todos los archivos js / css, excluyendo las gemas , en: app / assets, vendor / assets , lib / assets , a menos que sean archivos parciales (por ejemplo, "_file.sass"). También tiene una estrategia para incluir activos de gemas que no están incluidos en todas las páginas.

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

Aunque, probablemente no desee hacer esto, ya que probablemente esté precompilando activos de gemas dos veces (básicamente cualquier cosa que ya sea / = requerida en su application.js o css). Este fragmento incluye todos los archivos js / css, incluidas las gemas , en: app / assets, vendor / assets , lib / assets , a menos que sean archivos parciales (por ejemplo, "_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
}

Answer 4

Esto obtendrá todos los archivos .scss y .js incluidos todos los archivos en subdirectorios.

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)

Answer 5

Quería que se compilaran todos los recursos de / app y / vendor, excepto los parciales (cuyo nombre comienza desde el guión bajo _). Así que aquí está mi versión de una entrada en application.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
}

Además, muestra la lista de archivos que se compilan para fines de depuración ...

Answer 6

Un ligero ajuste a la respuesta de techpeace:

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

Hubiera agregado un comentario a su respuesta, pero aún no tengo suficiente reputación. ¡Dame un voto positivo y estaré allí!

NOTA: esto también precompilará todo el CSS / JavaScript incluido a través de rubygems.

Answer 7

Volveré a visitar esta publicación en el año 2017.

Nuestro producto todavía utiliza mucho RoR, hemos estado modificando continuamente nuestras configuraciones de precompilación añadiendo Rails.application.config.assets.precompile medida que agregamos nuevos módulos. Recientemente estaba tratando de optimizar esto agregando un patrón de expresiones regulares, encontré que el siguiente patrón global funciona:

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

Sin embargo, todavía tengo que excluir ciertos módulos, así que traté de usar regex en lugar de glob.

Hasta que investigué el código fuente de los piñones: https://github.com/rails/sprockets-rails/blob/master/lib/sprockets/railtie.rb#L108 , descubrí que ya están usando regex:

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

Entonces cambio mi código a:

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

Que funciona bien

Answer 8

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

Eso compilará cualquier JavaScript o CSS en la ruta de su activo, independientemente de la profundidad del directorio. Encontrado a través de esta respuesta .