Merge pull request #3225 from mjtko/assets-compilation-refactoring-th…

…e-sequel

assets rake task refactoring work - the sequel

actionpack/lib/sprockets/assets.rake

@@ -2,16 +2,23 @@ require "fileutils"
 
 namespace :assets do
   def ruby_rake_task(task)
-    args = [$0, task]
+    env = ENV['RAILS_ENV'] || 'production'
+    groups = ENV['RAILS_GROUPS'] || 'assets'
+    args = [$0, task,"RAILS_ENV=#{env}","RAILS_GROUPS=#{groups}"]
     args << "--trace" if Rake.application.options.trace
     ruby *args
   end
 
   desc "Compile all the assets named in config.assets.precompile"
   task :precompile do
-    ENV["RAILS_GROUPS"] ||= "assets"
-    ENV["RAILS_ENV"]    ||= "production"
-    ruby_rake_task "assets:precompile:all"
+    if ENV['RAILS_GROUPS'].to_s.empty? || ENV['RAILS_ENV'].to_s.empty?
+      # We are currently running with no explicit bundler group
+      # and/or no explicit environment - we have to reinvoke rake to
+      # execute this task.
+      ruby_rake_task "assets:precompile:all"
+    else
+      Rake::Task["assets:precompile:all"].invoke
+    end
   end
 
   namespace :precompile do
@@ -28,28 +35,32 @@ namespace :assets do
       config = Rails.application.config
       config.assets.compile = true
       config.assets.digest  = digest unless digest.nil?
+
       config.assets.digests = {}
 
       env    = Rails.application.assets
       target = File.join(Rails.public_path, config.assets.prefix)
-      static_compiler = Sprockets::StaticCompiler.new(env, target, :digest => config.assets.digest)
-      static_compiler.precompile(config.assets.precompile)
+      compiler = Sprockets::StaticCompiler.new(env, 
+                                               target,
+                                               config.assets.precompile,
+                                               :manifest_path => config.assets.manifest,
+                                               :digest => config.assets.digest,
+                                               :manifest => digest.nil?)
+      compiler.compile
     end
 
     task :all do
-      Rake::Task["assets:precompile:digest"].invoke
-      ruby_rake_task "assets:precompile:nondigest"
+      Rake::Task["assets:precompile:primary"].invoke
+      # We need to reinvoke in order to run the secondary digestless
+      # asset compilation run - a fresh Sprockets environment is
+      # required in order to compile digestless assets as the
+      # environment has already cached the assets on the primary
+      # run.
+      ruby_rake_task "assets:precompile:nondigest" if Rails.application.config.assets.digest
     end
 
-    task :digest => ["assets:environment", "tmp:cache:clear"] do
-      manifest      = internal_precompile
-      config        = Rails.application.config
-      manifest_path = config.assets.manifest || File.join(Rails.public_path, config.assets.prefix)
-      FileUtils.mkdir_p(manifest_path)
-
-      File.open("#{manifest_path}/manifest.yml", 'wb') do |f|
-        YAML.dump(manifest, f)
-      end
+    task :primary => ["assets:environment", "tmp:cache:clear"] do
+      internal_precompile
     end
 
     task :nondigest => ["assets:environment", "tmp:cache:clear"] do
@@ -59,9 +70,14 @@ namespace :assets do
 
   desc "Remove compiled assets"
   task :clean do
-    ENV["RAILS_GROUPS"] ||= "assets"
-    ENV["RAILS_ENV"]    ||= "production"
-    ruby_rake_task "assets:clean:all"
+    if ENV['RAILS_GROUPS'].to_s.empty? || ENV['RAILS_ENV'].to_s.empty?
+      # We are currently running with no explicit bundler group
+      # and/or no explicit environment - we have to reinvoke rake to
+      # execute this task.
+      ruby_rake_task "assets:clean:all"
+    else
+      Rake::Task["assets:clean:all"].invoke
+    end
   end
 
   namespace :clean do

actionpack/lib/sprockets/static_compiler.rb

@@ -2,41 +2,50 @@
 
 module Sprockets
   class StaticCompiler
-    attr_accessor :env, :target, :digest
+    attr_accessor :env, :target, :paths
 
-    def initialize(env, target, options = {})
+    def initialize(env, target, paths, options = {})
       @env = env
       @target = target
+      @paths = paths
       @digest = options.key?(:digest) ? options.delete(:digest) : true
+      @manifest = options.key?(:manifest) ? options.delete(:manifest) : true
+      @manifest_path = options.delete(:manifest_path) || target
     end
 
-    def precompile(paths)
-      Rails.application.config.assets.digest = digest
+    def compile
       manifest = {}
-
       env.each_logical_path do |logical_path|
-        next unless precompile_path?(logical_path, paths)
+        next unless compile_path?(logical_path)
         if asset = env.find_asset(logical_path)
-          manifest[logical_path] = compile(asset)
+          manifest[logical_path] = write_asset(asset)
         end
       end
-      manifest
+      write_manifest(manifest) if @manifest
     end
 
-    def compile(asset)
-      asset_path = digest_asset(asset)
-      filename = File.join(target, asset_path)
-      FileUtils.mkdir_p File.dirname(filename)
-      asset.write_to(filename)
-      asset.write_to("#{filename}.gz") if filename.to_s =~ /\.(css|js)$/
-      asset_path
+    def write_manifest(manifest)
+      FileUtils.mkdir_p(@manifest_path)
+      File.open("#{@manifest_path}/manifest.yml", 'wb') do |f|
+        YAML.dump(manifest, f)
+      end
+    end
+
+    def write_asset(asset)
+      path_for(asset).tap do |path|
+        filename = File.join(target, path)
+        FileUtils.mkdir_p File.dirname(filename)
+        asset.write_to(filename)
+        asset.write_to("#{filename}.gz") if filename.to_s =~ /\.(css|js)$/
+      end
     end
 
-    def precompile_path?(logical_path, paths)
+    def compile_path?(logical_path)
       paths.each do |path|
-        if path.is_a?(Regexp)
+        case path
+        when Regexp
           return true if path.match(logical_path)
-        elsif path.is_a?(Proc)
+        when Proc
           return true if path.call(logical_path)
         else
           return true if File.fnmatch(path.to_s, logical_path)
@@ -45,8 +54,8 @@ def precompile_path?(logical_path, paths)
       false
     end
 
-    def digest_asset(asset)
-      digest ? asset.digest_path : asset.logical_path
+    def path_for(asset)
+      @digest ? asset.digest_path : asset.logical_path
     end
   end
 end