turbo-sprockets-rails3-envaware 0.3.10

data/lib/turbo-sprockets-rails3.rb

@@ -0,0 +1,15 @@
+require 'sprockets/railtie'
+
+module Sprockets
+  # Assets
+  autoload :UnprocessedAsset,      "sprockets/unprocessed_asset"
+  autoload :AssetWithDependencies, "sprockets/asset_with_dependencies"
+end
+
+require 'sprockets'
+Dir[File.expand_path('../turbo-sprockets/sprockets_overrides/*.rb', __FILE__)].each do |f|
+  require f
+end
+
+require 'turbo-sprockets/helpers'
+require 'turbo-sprockets/railtie'

data/lib/turbo-sprockets/helpers.rb

@@ -0,0 +1,9 @@
+module TurboSprockets
+  def self.get_source_manifest_path(manifest_dir, filename="sources_manifest.yml")
+    "#{manifest_dir}/#{get_source_manifest_filename(filename)}"
+  end
+
+  def self.get_source_manifest_filename(filename="sources_manifest.yml")
+    ENV['RAILS_ENV'] ? "#{ENV['RAILS_ENV'].downcase}_#{filename}" : filename
+  end
+end

data/lib/turbo-sprockets/railtie.rb

@@ -0,0 +1,26 @@
+require "action_controller/railtie"
+
+module Sprockets
+  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
+
+      manifest_dir = config.assets.manifest || File.join(Rails.public_path, config.assets.prefix)
+      digests_manifest = File.join(manifest_dir, "manifest.yml")
+      sources_manifest = File.join(TurboSprockets.get_source_manifest_path(manifest_dir))
+      config.assets.digests        = (File.exist?(digests_manifest) && YAML.load_file(digests_manifest)) || {}
+      config.assets.source_digests = (File.exist?(sources_manifest) && YAML.load_file(sources_manifest)) || {}
+
+      # Clear digests if loading previous manifest format
+      config.assets.digests = {} if config.assets.digests[:digest_files]
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'sprockets/asset'
+
+module 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
+end

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

@@ -0,0 +1,38 @@
+require 'sprockets/base'
+
+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)
+      key = "#{path}:#{options[:bundle] ? '1' : '0'}"
+      key << ":0" unless options[:process]
+      key
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'sprockets/bundled_asset'
+
+module 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
+end

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

@@ -0,0 +1,21 @@
+require 'sprockets/environment'
+
+module 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
+end

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

@@ -0,0 +1,30 @@
+require 'sprockets/index'
+
+module 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
+end

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

@@ -0,0 +1,29 @@
+require 'sprockets/processed_asset'
+
+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,94 @@
+begin
+  require 'sprockets/static_compiler'
+rescue LoadError
+end
+
+# Sprockets::StaticCompiler was only introduced in Rails 3.2.x
+if defined?(Sprockets::StaticCompiler)
+  module 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_digests        = options.fetch(:digests,   {})
+
+        @digests        = {}
+        @source_digests = {}
+      end
+
+      def compile
+        start_time = Time.now.to_f
+
+        env.each_logical_path(paths) do |logical_path|
+          # Fetch asset without any processing or compression,
+          # to calculate a digest of the concatenated source files
+          next unless asset = env.find_asset(logical_path, :process => false)
+          @source_digests[logical_path] = asset.digest
+
+          # Recompile if digest has changed or compiled digest file is missing
+          current_digest_file = @current_digests[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_path = write_asset(asset)
+              @digests[asset.logical_path] = digest_path
+              @digests[aliased_path_for(asset.logical_path)] = digest_path
+              # Update current_digests with new hash, for future assets to reference
+              @current_digests[asset.logical_path] = asset.digest_path
+            end
+          else
+            # Set asset file from manifest.yml
+            digest_path = @current_digests[logical_path]
+            @digests[logical_path] = digest_path
+            @digests[aliased_path_for(logical_path)] = digest_path
+
+            env.logger.debug "Not compiling #{logical_path}, sources digest has not changed " <<
+                             "(#{@source_digests[logical_path][0...7]})"
+          end
+        end
+
+        # Encode all filenames & digests as UTF-8 for Ruby 1.9,
+        # otherwise YAML dumps other string encodings as !binary
+        if RUBY_VERSION.to_f >= 1.9
+          @source_digests = encode_hash_as_utf8 @source_digests
+          @digests        = encode_hash_as_utf8 @digests
+        end
+
+        if @manifest
+          write_manifest(@digests)
+          write_sources_manifest(@source_digests)
+        end
+
+        # Store digests in Rails config. (Important if non-digest is run after primary)
+        config = ::Rails.application.config
+        config.assets.digests        = @digests
+        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
+
+      def write_sources_manifest(source_digests)
+        FileUtils.mkdir_p(@manifest_path)
+        File.open(TurboSprockets.get_source_manifest_path(@manifest_path), 'wb') do |f|
+          YAML.dump(source_digests, f)
+        end
+      end
+
+      private
+
+      def encode_hash_as_utf8(hash)
+        Hash[*hash.map {|k,v| [k.encode("UTF-8"), v.encode("UTF-8")] }.flatten]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,204 @@
+require "fileutils"
+require 'shellwords'
+
+# Clear all assets tasks from sprockets railtie,
+# but preserve any extra actions added via 'enhance'
+task_enhancements = {}
+Rake::Task.tasks.each do |task|
+  if task.name.match '^assets:'
+    task_enhancements[task.name] = task.actions[1..-1] if task.actions.size > 1
+    task.clear
+  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
+
+  # Returns an array of assets recognized by config.assets.digests,
+  # including gzipped assets and manifests
+  def known_assets
+    assets = Rails.application.config.assets.digests.to_a.flatten.map do |asset|
+      [asset, "#{asset}.gz"]
+    end.flatten
+    assets + (%w(manifest.yml) << TurboSprockets.get_source_manifest_filename)
+  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.clean_after_precompile = false if config.assets.clean_after_precompile.nil?
+      config.assets.digest = digest unless digest.nil?
+      config.assets.digests        ||= {}
+      config.assets.source_digests ||= {}
+      config.assets.handle_expiration = false if config.assets.handle_expiration.nil?
+
+      env    = Rails.application.assets
+      target = File.join(::Rails.public_path, config.assets.prefix)
+
+      # This takes a long time to run if you aren't cleaning expired assets.
+      # You must call the assets:clean_expired rake task regularly if this is
+      # enabled
+      if config.assets.handle_expiration
+        # Before first compile, set the mtime of all current assets to current time.
+        # This time reflects the last time the assets were being used.
+        if digest.nil?
+          ::Rails.logger.debug "Updating mtimes for current assets..."
+          paths = known_assets.map { |asset| File.join(target, asset) }
+          paths.each_slice(100) do |slice|
+            # File.utime raises 'Operation not permitted' unless user is owner of file.
+            # Non-owners have permission to update mtime to the current time using 'touch'.
+            `touch -c #{slice.shelljoin}`
+          end
+        end
+      end
+
+      # 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.digests.any?
+        generator = Sprockets::StaticNonDigestGenerator.new(env, target, config.assets.precompile,
+          :digests => config.assets.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,
+          :digests        => config.assets.digests,
+          :source_digests => config.assets.source_digests
+        )
+        compiler.compile
+      end
+    end
+
+    task :all => ["assets:cache:clean"] do
+      # Other gems may want to add hooks to run after the 'assets:precompile:***' tasks.
+      # Since we aren't running separate rake tasks anymore, we manually invoke the extra actions.
+      internal_precompile
+      Rake::Task["assets:precompile:primary"].actions[1..-1].each &:call
+
+      if ::Rails.application.config.assets.digest
+        internal_precompile(false)
+        Rake::Task["assets:precompile:nondigest"].actions[1..-1].each &:call
+      end
+    end
+
+    task :primary => ["assets:cache:clean"] do
+      internal_precompile
+    end
+
+    task :nondigest => ["assets:cache:clean"] do
+      internal_precompile(false)
+    end
+  end
+
+  desc "Remove old assets that aren't referenced by manifest.yml"
+  task :clean_expired do
+    invoke_or_reboot_rake_task "assets:clean_expired:all"
+  end
+
+  # Remove assets that haven't been deployed since `config.assets.expire_after` (default 1 day).
+  # This provides a buffer between deploys, so that older assets can still be requested.
+  # The precompile task updates the mtime of the current assets before compiling,
+  # which indicates when they were last in use.
+  #
+  # The current assets are ignored, which is faster than the alternative of
+  # setting their mtimes only to check them again.
+  namespace :clean_expired do
+    task :all => ["assets:environment"] do
+      config = ::Rails.application.config
+      expire_after = config.assets.expire_after || 1.day
+      public_asset_path = File.join(::Rails.public_path, config.assets.prefix)
+
+      @known_assets = known_assets
+
+      Dir.glob(File.join(public_asset_path, '**/*')).each do |asset|
+        next if File.directory?(asset)
+        logical_path = asset.sub("#{public_asset_path}/", '')
+
+        unless logical_path.in?(@known_assets)
+          # Delete asset if not used for more than expire_after seconds
+          if File.mtime(asset) < (Time.now - expire_after)
+            ::Rails.logger.debug "Removing expired asset: #{logical_path}"
+            FileUtils.rm_f asset
+          end
+        end
+      end
+    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 => ["assets:environment"] do
+      FileUtils.mkdir_p(File.join(::Rails.root.to_s, *%w(tmp cache assets)))
+      ::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
+
+
+# Append previous task enhancements to new Rake tasks.
+task_enhancements.each do |task_name, actions|
+  actions.each do |proc|
+    Rake::Task[task_name].enhance &proc
+  end
+end