turbo-sprockets-rails3 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Nathan D. Broadbent
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,36 @@
+# Turbo Sprockets for Rails 3
+
+* Speeds up the Rails 3 asset pipeline by only recompiling changed assets
+* Generates non-digest assets from precompiled assets - Only compile once!
+
+This is a backport of the work I've done for Rails 4.0.0, released as
+a gem for Rails 3.2.x. (See [sprockets-rails #21](https://github.com/rails/sprockets-rails/pull/21) and [sprockets #367](https://github.com/sstephenson/sprockets/pull/367) for the Rails 4 pull requests.)
+
+### Disclaimer
+
+Please test this out thoroughly on your local machine before deploying to a production site, and open an issue on GitHub if you have any problems. By using this software you agree to the terms and conditions in the [MIT license](https://github.com/ndbroadbent/turbo-sprockets-rails3/blob/master/MIT-LICENSE).
+
+### Dependencies
+
+* sprockets `~> 2.1.3`
+* railties `~> 3.2.0`
+
+### Usage
+
+Just drop the gem in your `Gemfile`, in the `:assets` group:
+
+```ruby
+group :assets do
+  ...
+
+  gem 'turbo-sprockets-rails3'
+end
+```
+
+Run `bundle`, and you're done!
+
+Test it out by running `rake assets:precompile`. When it's finished, your `public/assets/manifest.yml` file should include a `:source_digests` hash for your assets.
+
+Go on, run `rake assets:precompile` again, and it should be a whole lot faster than before.
+
+Enjoy your lightning fast deploys!

data/Rakefile

@@ -0,0 +1,25 @@
+#!/usr/bin/env rake
+require 'rake/testtask'
+ENV["TEST_CORES"] = "1"
+
+namespace :test do
+  task :isolated do
+    Dir["test/assets*_test.rb"].each do |file|
+      dash_i = [
+        'test',
+        'lib',
+      ]
+      ruby "-I#{dash_i.join ':'}", file
+    end
+  end
+end
+
+Rake::TestTask.new("test:regular") do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/sprockets*_test.rb'
+  t.verbose = true
+end
+
+task :test => ['test:isolated', 'test:regular']
+task :default => :test

data/lib/sprockets/asset_with_dependencies.rb

@@ -0,0 +1,134 @@
+require 'sprockets/asset'
+require 'sprockets/utils'
+
+module Sprockets
+  # `AssetWithDependencies` is the base class for `ProcessedAsset` and `UnprocessedAsset`.
+  class AssetWithDependencies < Asset
+
+    # :dependency_digest is used internally to check equality
+    attr_reader :dependency_digest, :source
+
+
+    # Initialize asset from serialized hash
+    def init_with(environment, coder, asset_options = {})
+      asset_options[:bundle] = false
+
+      super(environment, coder)
+
+      @source = coder['source']
+      @dependency_digest = coder['dependency_digest']
+
+      @required_assets = coder['required_paths'].map { |p|
+        p = expand_root_path(p)
+
+        unless environment.paths.detect { |path| p[path] }
+          raise UnserializeError, "#{p} isn't in paths"
+        end
+
+        p == pathname.to_s ? self : environment.find_asset(p, asset_options)
+      }
+      @dependency_paths = coder['dependency_paths'].map { |h|
+        DependencyFile.new(expand_root_path(h['path']), h['mtime'], h['digest'])
+      }
+    end
+
+    # Serialize custom attributes.
+    def encode_with(coder)
+      super
+
+      coder['source'] = source
+      coder['dependency_digest'] = dependency_digest
+
+      coder['required_paths'] = required_assets.map { |a|
+        relativize_root_path(a.pathname).to_s
+      }
+      coder['dependency_paths'] = dependency_paths.map { |d|
+        { 'path' => relativize_root_path(d.pathname).to_s,
+          'mtime' => d.mtime.iso8601,
+          'digest' => d.digest }
+      }
+    end
+
+    # Checks if Asset is stale by comparing the actual mtime and
+    # digest to the inmemory model.
+    def fresh?(environment)
+      # Check freshness of all declared dependencies
+      @dependency_paths.all? { |dep| dependency_fresh?(environment, dep) }
+    end
+
+    protected
+      class DependencyFile < Struct.new(:pathname, :mtime, :digest)
+        def initialize(pathname, mtime, digest)
+          pathname = Pathname.new(pathname) unless pathname.is_a?(Pathname)
+          mtime    = Time.parse(mtime) if mtime.is_a?(String)
+          super
+        end
+
+        def eql?(other)
+          other.is_a?(DependencyFile) &&
+            pathname.eql?(other.pathname) &&
+            mtime.eql?(other.mtime) &&
+            digest.eql?(other.digest)
+        end
+
+        def hash
+          pathname.to_s.hash
+        end
+      end
+
+    private
+      def build_required_assets(environment, context, asset_options = {})
+        asset_options[:bundle] = false
+        @required_assets = []
+        required_assets_cache = {}
+
+        (context._required_paths + [pathname.to_s]).each do |path|
+          if path == self.pathname.to_s
+            unless required_assets_cache[self]
+              required_assets_cache[self] = true
+              @required_assets << self
+            end
+          elsif asset = environment.find_asset(path, asset_options)
+            asset.required_assets.each do |asset_dependency|
+              unless required_assets_cache[asset_dependency]
+                required_assets_cache[asset_dependency] = true
+                @required_assets << asset_dependency
+              end
+            end
+          end
+        end
+
+        required_assets_cache.clear
+        required_assets_cache = nil
+      end
+
+      def build_dependency_paths(environment, context, asset_options = {})
+        asset_options[:bundle] = false
+        dependency_paths = {}
+
+        context._dependency_paths.each do |path|
+          dep = DependencyFile.new(path, environment.stat(path).mtime, environment.file_digest(path).hexdigest)
+          dependency_paths[dep] = true
+        end
+
+        context._dependency_assets.each do |path|
+          if path == self.pathname.to_s
+            dep = DependencyFile.new(pathname, environment.stat(path).mtime, environment.file_digest(path).hexdigest)
+            dependency_paths[dep] = true
+          elsif asset = environment.find_asset(path, asset_options)
+            asset.dependency_paths.each do |d|
+              dependency_paths[d] = true
+            end
+          end
+        end
+
+        @dependency_paths = dependency_paths.keys
+      end
+
+      def compute_dependency_digest(environment)
+        required_assets.inject(environment.digest) { |digest, asset|
+          digest.update asset.digest
+        }.hexdigest
+      end
+  end
+end

data/lib/sprockets/static_cleaner.rb

@@ -0,0 +1,41 @@
+require 'fileutils'
+
+module Sprockets
+  class StaticCleaner
+    attr_accessor :env, :target
+
+    def initialize(env, target, digest_files)
+      @env = env
+      @target = File.join(target, '') # Make sure target ends with trailing /
+      @digest_files = digest_files
+    end
+
+    # Remove all files from `config.assets.prefix` that are not found in manifest.yml
+    def remove_old_assets!
+      known_files = @digest_files.flatten
+      known_files += known_files.map {|f| "#{f}.gz" } # Recognize gzipped files
+      known_files << 'manifest.yml'
+
+      assets_prefix = ::Rails.application.config.assets.prefix
+
+      Dir[File.join(target, "**/*")].each do |path|
+        unless File.directory?(path)
+          logical_path = path.sub(target, '')
+          unless logical_path.in? known_files
+            FileUtils.rm path
+            env.logger.debug "Deleted old asset at public#{assets_prefix}/#{logical_path}"
+          end
+        end
+      end
+
+      # Remove empty directories (reversed to delete top-level empty dirs first)
+      Dir[File.join(target, "**/*")].reverse.each do |path|
+        if File.exists?(path) && File.directory?(path) && (Dir.entries(path) - %w(. ..)).empty?
+          FileUtils.rmdir path
+          logical_path = path.sub(target, '')
+          env.logger.debug "Deleted empty directory at public#{assets_prefix}/#{logical_path}"
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/static_non_digest_generator.rb

@@ -0,0 +1,99 @@
+require 'fileutils'
+
+module Sprockets
+  class StaticNonDigestGenerator
+
+    DIGEST_REGEX = /-([0-9a-f]{32})/
+
+    attr_accessor :env, :target, :paths
+
+    def initialize(env, target, paths, options = {})
+      @env = env
+      @target = target
+      @paths = paths
+      @digest_files = options.fetch(:digest_files, {})
+
+      # Parse digests from digest_files hash
+      @asset_digests = Hash[*@digest_files.map {|file, digest_file|
+        [file, digest_file[DIGEST_REGEX, 1]]
+      }.flatten]
+    end
+
+
+    # Generate non-digest assets by making a copy of the digest asset,
+    # with digests stripped from js and css. The new files are also gzipped.
+    # Other assets are copied verbatim.
+    def generate
+      start_time = Time.now.to_f
+
+      env.each_logical_path do |logical_path|
+        next unless compile_path?(logical_path)
+
+        digest_path      = @digest_files[logical_path]
+        abs_digest_path  = "#{@target}/#{digest_path}"
+        abs_logical_path = "#{@target}/#{logical_path}"
+
+        mtime = File.mtime(abs_digest_path)
+
+        # Remove known digests from css & js
+        if abs_digest_path.match(/\.(?:js|css)$/)
+          asset_body = File.read(abs_digest_path)
+
+          # Find all hashes in the asset body with a leading '-'
+          asset_body.gsub!(DIGEST_REGEX) do |match|
+            # Only remove if known digest
+            $1.in?(@asset_digests.values) ? '' : match
+          end
+
+          # Write non-digest file
+          File.open abs_logical_path, 'w' do |f|
+            f.write asset_body
+          end
+          # Set modification and access times
+          File.utime(File.atime(abs_digest_path), mtime, abs_logical_path)
+
+          # Also write gzipped asset
+          File.open("#{abs_logical_path}.gz", 'wb') do |f|
+            gz = Zlib::GzipWriter.new(f, Zlib::BEST_COMPRESSION)
+            gz.mtime = mtime.to_i
+            gz.write asset_body
+            gz.close
+          end
+
+          env.logger.debug "Stripped digests, copied to #{logical_path}, and created gzipped asset"
+
+        else
+          # Otherwise, treat file as binary and copy it
+          FileUtils.cp_r abs_digest_path, abs_logical_path, :remove_destination => true
+          env.logger.debug "Copied binary asset to #{logical_path}"
+
+          # Copy gzipped asset if exists
+          if File.exist? "#{abs_digest_path}.gz"
+            FileUtils.cp_r "#{abs_digest_path}.gz", "#{abs_logical_path}.gz", :remove_destination => true
+            env.logger.debug "Copied gzipped asset to #{logical_path}.gz"
+          end
+        end
+      end
+
+
+      elapsed_time = ((Time.now.to_f - start_time) * 1000).to_i
+      env.logger.debug "Generated non-digest assets in #{elapsed_time}ms"
+    end
+
+    private
+
+    def compile_path?(logical_path)
+      paths.each do |path|
+        case path
+        when Regexp
+          return true if path.match(logical_path)
+        when Proc
+          return true if path.call(logical_path)
+        else
+          return true if File.fnmatch(path.to_s, logical_path)
+        end
+      end
+      false
+    end
+  end
+end

data/lib/sprockets/unprocessed_asset.rb

@@ -0,0 +1,28 @@
+require 'sprockets/asset_with_dependencies'
+
+module Sprockets
+  class UnprocessedAsset < AssetWithDependencies
+    def initialize(environment, logical_path, pathname)
+      super
+
+      context = environment.context_class.new(environment, logical_path, pathname)
+      attributes = environment.attributes_for(pathname)
+      processors = attributes.processors
+
+      # Remove all engine processors except ERB to return unprocessed source file
+      processors -= (attributes.engines - [Tilt::ERBTemplate])
+
+      @source = context.evaluate(pathname, :processors => processors)
+
+      build_required_assets(environment, context,  :process => false)
+      build_dependency_paths(environment, context, :process => false)
+
+      @dependency_digest = compute_dependency_digest(environment)
+    end
+  end
+
+  # Return unprocessed dependencies when initializing asset from serialized hash
+  def init_with(environment, coder)
+    super(environment, coder, :process => false)
+  end
+end

data/lib/turbo-sprockets/railtie.rb

@@ -0,0 +1,30 @@
+require "action_controller/railtie"
+
+module Sprockets
+  autoload :StaticCleaner,            "sprockets/static_cleaner"
+  autoload :StaticNonDigestGenerator, "sprockets/static_non_digest_generator"
+end
+
+module TurboSprockets
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load "turbo-sprockets/tasks/assets.rake"
+    end
+
+    initializer "turbo-sprockets.environment", :after => "sprockets.environment", :group => :all do |app|
+      config = app.config
+
+      if config.assets.manifest
+        manifest_path = File.join(config.assets.manifest, "manifest.yml")
+      else
+        manifest_path = File.join(Rails.public_path, config.assets.prefix, "manifest.yml")
+      end
+
+      if File.exist?(manifest_path)
+        manifest = YAML.load_file(manifest_path)
+        config.assets.digest_files   = manifest[:digest_files]   || {}
+        config.assets.source_digests = manifest[:source_digests] || {}
+      end
+    end
+  end
+end

data/lib/turbo-sprockets/sprockets_overrides/asset.rb

@@ -0,0 +1,29 @@
+require 'sprockets/asset'
+
+Sprockets::Asset.class_eval do
+  # Internal initializer to load `Asset` from serialized `Hash`.
+  def self.from_hash(environment, hash)
+    return unless hash.is_a?(Hash)
+
+    klass = case hash['class']
+      when 'BundledAsset'
+        BundledAsset
+      when 'ProcessedAsset'
+        ProcessedAsset
+      when 'UnprocessedAsset'
+        UnprocessedAsset
+      when 'StaticAsset'
+        StaticAsset
+      else
+        nil
+      end
+
+    if klass
+      asset = klass.allocate
+      asset.init_with(environment, hash)
+      asset
+    end
+  rescue UnserializeError
+    nil
+  end
+end

data/lib/turbo-sprockets/sprockets_overrides/base.rb

@@ -0,0 +1,37 @@
+require 'sprockets/base'
+require 'sprockets/unprocessed_asset'
+
+module Sprockets
+  Base.class_eval do
+    protected
+
+    def build_asset(logical_path, pathname, options)
+      pathname = Pathname.new(pathname)
+
+      # If there are any processors to run on the pathname, use
+      # `BundledAsset`. Otherwise use `StaticAsset` and treat is as binary.
+      if attributes_for(pathname).processors.any?
+        if options[:bundle] == false
+          circular_call_protection(pathname.to_s) do
+            if options[:process] == false
+              UnprocessedAsset.new(index, logical_path, pathname)
+            else
+              ProcessedAsset.new(index, logical_path, pathname)
+            end
+          end
+        else
+          BundledAsset.new(index, logical_path, pathname, options)
+        end
+      else
+        StaticAsset.new(index, logical_path, pathname)
+      end
+    end
+
+    private
+
+    def cache_key_for(path, options)
+      options[:process] = true unless options.key?(:process)
+      "#{path}:#{options[:bundle] ? '1' : '0'}:#{options[:process] ? '1' : '0'}"
+    end
+  end
+end

data/lib/turbo-sprockets/sprockets_overrides/bundled_asset.rb

@@ -0,0 +1,31 @@
+require 'sprockets/bundled_asset'
+
+Sprockets::BundledAsset.class_eval do
+
+  # Adds :process options
+
+  def initialize(environment, logical_path, pathname, options = {})
+    super(environment, logical_path, pathname)
+    @process = options.fetch(:process, true)
+
+    @processed_asset  = environment.find_asset(pathname, :bundle => false, :process => @process)
+    @required_assets  = @processed_asset.required_assets
+    @dependency_paths = @processed_asset.dependency_paths
+
+    @source = ""
+
+    # Explode Asset into parts and gather the dependency bodies
+    to_a.each { |dependency| @source << dependency.to_s }
+
+    if @process
+      # Run bundle processors on concatenated source
+      context = environment.context_class.new(environment, logical_path, pathname)
+      @source = context.evaluate(pathname, :data => @source,
+                  :processors => environment.bundle_processors(content_type))
+    end
+
+    @mtime  = to_a.map(&:mtime).max
+    @length = Rack::Utils.bytesize(source)
+    @digest = environment.digest.update(source).hexdigest
+  end
+end

data/lib/turbo-sprockets/sprockets_overrides/environment.rb

@@ -0,0 +1,19 @@
+require 'sprockets/environment'
+
+Sprockets::Environment.class_eval do
+
+  # Adds :process options
+
+  def find_asset(path, options = {})
+    options[:bundle] = true unless options.key?(:bundle)
+    options[:process] = true unless options.key?(:process)
+
+    # Ensure in-memory cached assets are still fresh on every lookup
+    if (asset = @assets[cache_key_for(path, options)]) && asset.fresh?(self)
+      asset
+    elsif asset = index.find_asset(path, options)
+      # Cache is pushed upstream by Index#find_asset
+      asset
+    end
+  end
+end

data/lib/turbo-sprockets/sprockets_overrides/helpers/rails_helper.rb

@@ -0,0 +1,42 @@
+require 'sprockets/helpers/rails_helper'
+
+module Sprockets
+  module Helpers
+    RailsHelper.module_eval do
+      def asset_paths
+        @asset_paths ||= begin
+          paths = RailsHelper::AssetPaths.new(config, controller)
+          paths.asset_environment = asset_environment
+          paths.digest_files      = digest_files
+          paths.compile_assets    = compile_assets?
+          paths.digest_assets     = digest_assets?
+          paths
+        end
+      end
+
+      private
+      def digest_files
+        Rails.application.config.assets.digest_files
+      end
+    end
+
+    RailsHelper::AssetPaths.class_eval do
+      attr_accessor :digest_files
+
+      def digest_for(logical_path)
+        if digest_assets && digest_files && (digest = digest_files[logical_path])
+          return digest
+        end
+
+        if compile_assets
+          if digest_assets && asset = asset_environment[logical_path]
+            return asset.digest_path
+          end
+          return logical_path
+        else
+          raise AssetNotPrecompiledError.new("#{logical_path} isn't precompiled")
+        end
+      end
+    end
+  end
+end

data/lib/turbo-sprockets/sprockets_overrides/index.rb

@@ -0,0 +1,28 @@
+require 'sprockets/index'
+
+Sprockets::Index.class_eval do
+
+  # Adds :process options
+
+  def find_asset(path, options = {})
+    options[:bundle]  = true unless options.key?(:bundle)
+    options[:process] = true unless options.key?(:process)
+
+    if asset = @assets[cache_key_for(path, options)]
+      asset
+    elsif asset = super
+      logical_path_cache_key = cache_key_for(path, options)
+      full_path_cache_key    = cache_key_for(asset.pathname, options)
+
+      # Cache on Index
+      @assets[logical_path_cache_key] = @assets[full_path_cache_key] = asset
+
+      # Push cache upstream to Environment
+      @environment.instance_eval do
+        @assets[logical_path_cache_key] = @assets[full_path_cache_key] = asset
+      end
+
+      asset
+    end
+  end
+end

data/lib/turbo-sprockets/sprockets_overrides/processed_asset.rb

@@ -0,0 +1,30 @@
+require 'sprockets/processed_asset'
+require 'sprockets/asset_with_dependencies'
+
+module Sprockets
+
+  # Remove and redefine ProcessedAsset to inherit from AssetWithDependencies
+
+  remove_const :ProcessedAsset
+
+  class ProcessedAsset < AssetWithDependencies
+    def initialize(environment, logical_path, pathname)
+      super
+
+      start_time = Time.now.to_f
+
+      context = environment.context_class.new(environment, logical_path, pathname)
+      @source = context.evaluate(pathname)
+      @length = Rack::Utils.bytesize(source)
+      @digest = environment.digest.update(source).hexdigest
+
+      build_required_assets(environment, context)
+      build_dependency_paths(environment, context)
+
+      @dependency_digest = compute_dependency_digest(environment)
+
+      elapsed_time = ((Time.now.to_f - start_time) * 1000).to_i
+      environment.logger.info "Compiled #{logical_path}  (#{elapsed_time}ms)  (pid #{Process.pid})"
+    end
+  end
+end

data/lib/turbo-sprockets/sprockets_overrides/static_compiler.rb

@@ -0,0 +1,68 @@
+require 'sprockets/static_compiler'
+
+Sprockets::StaticCompiler.class_eval do
+  def initialize(env, target, paths, options = {})
+    @env = env
+    @target = target
+    @paths = paths
+    @digest = options.fetch(:digest, true)
+    @manifest = options.fetch(:manifest, true)
+    @manifest_path = options.delete(:manifest_path) || target
+    @zip_files = options.delete(:zip_files) || /\.(?:css|html|js|svg|txt|xml)$/
+
+    @current_source_digests = options.fetch(:source_digests, {})
+    @current_digest_files   = options.fetch(:digest_files,   {})
+
+    @digest_files   = {}
+    @source_digests = {}
+  end
+
+  def compile
+    start_time = Time.now.to_f
+
+    env.each_logical_path do |logical_path|
+      if File.basename(logical_path)[/[^\.]+/, 0] == 'index'
+        logical_path.sub!(/\/index\./, '.')
+      end
+      next unless compile_path?(logical_path)
+
+      # Fetch asset without any processing or compression,
+      # to calculate a digest of the concatenated source files
+      asset = env.find_asset(logical_path, :process => false)
+
+      # Force digest to UTF-8, otherwise YAML dumps ASCII-8BIT as !binary
+      @source_digests[logical_path] = asset.digest.force_encoding("UTF-8")
+
+      # Recompile if digest has changed or compiled digest file is missing
+      current_digest_file = @current_digest_files[logical_path]
+
+      if @source_digests[logical_path] != @current_source_digests[logical_path] ||
+         !(current_digest_file && File.exists?("#{@target}/#{current_digest_file}"))
+
+        if asset = env.find_asset(logical_path)
+          @digest_files[logical_path] = write_asset(asset)
+        end
+
+      else
+        # Set asset file from manifest.yml
+        digest_file = @current_digest_files[logical_path]
+        @digest_files[logical_path] = digest_file
+
+        env.logger.debug "Not compiling #{logical_path}, sources digest has not changed " <<
+                         "(#{@source_digests[logical_path][0...7]})"
+      end
+    end
+
+    if @manifest
+      write_manifest(source_digests: @source_digests, digest_files: @digest_files)
+    end
+
+    # Store digests in Rails config. (Important if non-digest is run after primary)
+    config = ::Rails.application.config
+    config.assets.digest_files   = @digest_files
+    config.assets.source_digests = @source_digests
+
+    elapsed_time = ((Time.now.to_f - start_time) * 1000).to_i
+    env.logger.debug "Processed #{'non-' unless @digest}digest assets in #{elapsed_time}ms"
+  end
+end

data/lib/turbo-sprockets/tasks/assets.rake

@@ -0,0 +1,128 @@
+require "fileutils"
+
+# Clear all assets tasks from sprockets railtie
+Rake::Task.tasks.each do |task|
+  if task.name.starts_with? 'assets:'
+    task.clear_prerequisites.clear_actions
+  end
+end
+
+# Replace with our extended assets tasks
+namespace :assets do
+  def ruby_rake_task(task, fork = true)
+    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
+    if $0 =~ /rake\.bat\Z/i
+      Kernel.exec $0, *args
+    else
+      fork ? ruby(*args) : Kernel.exec(FileUtils::RUBY, *args)
+    end
+  end
+
+  # We are currently running with no explicit bundler group
+  # and/or no explicit environment - we have to reinvoke rake to
+  # execute this task.
+  def invoke_or_reboot_rake_task(task)
+    if ENV['RAILS_GROUPS'].to_s.empty? || ENV['RAILS_ENV'].to_s.empty?
+      ruby_rake_task task
+    else
+      Rake::Task[task].invoke
+    end
+  end
+
+  desc "Compile all the assets named in config.assets.precompile"
+  task :precompile do
+    invoke_or_reboot_rake_task "assets:precompile:all"
+  end
+
+  namespace :precompile do
+    def internal_precompile(digest=nil)
+      unless Rails.application.config.assets.enabled
+        warn "Cannot precompile assets if sprockets is disabled. Please set config.assets.enabled to true"
+        exit
+      end
+
+      # Ensure that action view is loaded and the appropriate
+      # sprockets hooks get executed
+      _ = ActionView::Base
+
+      config = Rails.application.config
+      config.assets.compile = true
+      config.assets.digest  = digest unless digest.nil?
+      config.assets.digest_files   ||= {}
+      config.assets.source_digests ||= {}
+
+      env    = Rails.application.assets
+      target = File.join(::Rails.public_path, config.assets.prefix)
+
+      # If processing non-digest assets, and compiled digest files are
+      # present, then generate non-digest assets from existing assets.
+      # It is assumed that `assets:precompile:nondigest` won't be run manually
+      # if assets have been previously compiled with digests.
+      if !config.assets.digest && config.assets.digest_files.any?
+        generator = Sprockets::StaticNonDigestGenerator.new(env, target, config.assets.precompile,
+          :digest_files   => config.assets.digest_files,
+          :source_digests => config.assets.source_digests
+        )
+        generator.generate
+      else
+        compiler = Sprockets::StaticCompiler.new(env, target, config.assets.precompile,
+          :digest         => config.assets.digest,
+          :manifest       => digest.nil?,
+          :manifest_path  => config.assets.manifest,
+          :digest_files   => config.assets.digest_files,
+          :source_digests => config.assets.source_digests
+        )
+        compiler.compile
+      end
+
+      unless config.assets.clean_after_precompile == false
+        cleaner = Sprockets::StaticCleaner.new(env, target, config.assets.digest_files)
+        cleaner.remove_old_assets!
+      end
+    end
+
+    task :all => ["assets:cache:clean"] do
+      internal_precompile
+      internal_precompile(false) if ::Rails.application.config.assets.digest
+    end
+
+    task :primary => ["assets:cache:clean"] do
+      internal_precompile
+    end
+
+    task :nondigest => ["assets:cache:clean"] do
+      internal_precompile(false)
+    end
+  end
+
+  desc "Remove compiled assets"
+  task :clean do
+    invoke_or_reboot_rake_task "assets:clean:all"
+  end
+
+  namespace :clean do
+    task :all => ["assets:cache:clean"] do
+      config = ::Rails.application.config
+      public_asset_path = File.join(::Rails.public_path, config.assets.prefix)
+      rm_rf public_asset_path, :secure => true
+    end
+  end
+
+  namespace :cache do
+    task :clean => ['tmp:create', "assets:environment"] do
+      ::Rails.application.assets.cache.clear
+    end
+  end
+
+  task :environment do
+    if ::Rails.application.config.assets.initialize_on_precompile
+      Rake::Task["environment"].invoke
+    else
+      ::Rails.application.initialize!(:assets)
+      Sprockets::Bootstrap.new(Rails.application).run
+    end
+  end
+end

data/lib/turbo-sprockets/version.rb

@@ -0,0 +1,3 @@
+module TurboSprockets
+  VERSION = "0.1.0"
+end

data/lib/turbo-sprockets-rails3.rb

@@ -0,0 +1,5 @@
+Dir[File.expand_path('../turbo-sprockets/sprockets_overrides/**/*.rb', __FILE__)].each do |f|
+  require f
+end
+
+require 'turbo-sprockets/railtie'

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: turbo-sprockets-rails3
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Nathan Broadbent
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sprockets
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.3
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+description: Speeds up the Rails 3 asset pipeline by only recompiling changed assets
+email:
+- nathan.f77@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/turbo-sprockets-rails3.rb
+- lib/turbo-sprockets/version.rb
+- lib/turbo-sprockets/tasks/assets.rake
+- lib/turbo-sprockets/railtie.rb
+- lib/turbo-sprockets/sprockets_overrides/helpers/rails_helper.rb
+- lib/turbo-sprockets/sprockets_overrides/static_compiler.rb
+- lib/turbo-sprockets/sprockets_overrides/base.rb
+- lib/turbo-sprockets/sprockets_overrides/bundled_asset.rb
+- lib/turbo-sprockets/sprockets_overrides/index.rb
+- lib/turbo-sprockets/sprockets_overrides/asset.rb
+- lib/turbo-sprockets/sprockets_overrides/environment.rb
+- lib/turbo-sprockets/sprockets_overrides/processed_asset.rb
+- lib/sprockets/static_non_digest_generator.rb
+- lib/sprockets/asset_with_dependencies.rb
+- lib/sprockets/static_cleaner.rb
+- lib/sprockets/unprocessed_asset.rb
+- MIT-LICENSE
+- Rakefile
+- README.md
+homepage: https://github.com/ndbroadbent/turbo-sprockets-rails3
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Supercharge your Rails 3 asset pipeline
+test_files: []