turbo-sprockets-rails3-envaware 0.3.10

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 976e13e4c0895d50de8bcba8cae88e4a22bd18c8
+  data.tar.gz: 79b97c9d2816c9ed57b949d239a861888699975e
+SHA512:
+  metadata.gz: d00789a4955348cb975af9a9af1cbe60ab72f74d3c1481a485e8d7d0d242df442722909d97f8bc76c1fa29767c2f6db89d75991279515947517e4b9faf3c832f
+  data.tar.gz: 25dc178a73ff9ed5c7965ffa1defc45ce14b41c3ae6e4b9873af0da5b55d4207bc51c56a770e45467c02c37f7b43c22c5b1fce2a218fbcb5fca24bffd776a88a

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,117 @@
+# Turbo Sprockets for Rails 3.2.x
+
+[![Build Status](https://secure.travis-ci.org/ndbroadbent/turbo-sprockets-rails3.png)](http://travis-ci.org/ndbroadbent/turbo-sprockets-rails3)
+
+* Speeds up your Rails 3 `rake assets:precompile` by only recompiling changed assets, based on a hash of their source files
+* Only compiles once to generate both fingerprinted and non-fingerprinted assets
+
+
+### Disclaimer
+
+`turbo-sprockets-rails3` can now be considered relatively stable. A lot of compatibility issues and bugs have been solved, so you shouldn't run into any problems.
+However, please do test it out 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).
+
+
+## Usage
+
+Just drop the gem in your `Gemfile`, under the `:assets` group:
+
+```ruby
+group :assets do
+  ...
+  gem 'turbo-sprockets-rails3'
+end
+```
+
+Run `bundle` to install the gem, and you're done!
+
+Test it out by running `rake assets:precompile`. When it's finished, you should see a new file at `public/assets/sources_manifest.yml`, which includes the source fingerprints 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!
+
+## Removing Expired Assets
+
+`turbo-sprockets-rails3` provides a Rake task called `assets:clean_expired`. You can run this task after `assets:precompile` to remove outdated assets.
+
+If you use this rake task, you must set `config.assets.handle_expiration` to true in `config/environments/production.rb`. This makes sure that asset modification times
+are updated properly before `assets:precompile`, so that the `clean_expired` task knows which assets are safe to remove.
+
+An asset will be deleted if it is no longer referenced by `manifest.yml`, and hasn't been actively deployed for more than a day (default).
+
+You can configure the expiry time by setting `config.assets.expire_after` in `config/environments/production.rb`.
+An expiry time of 2 weeks could be configured with the following code:
+
+```ruby
+config.assets.expire_after 2.weeks
+```
+
+## Versioning
+
+The gem needs to support multiple changes to Rails and sprockets, so the following versioning is used:
+
+* Rails 3.2.0 to 3.2.8 uses `turbo-sprockets-rails3` `0.2.x`
+* Rails 3.2.9 and higher uses `turbo-sprockets-rails3` `0.3.x`
+
+
+## Compatibility
+
+### [asset_sync](https://github.com/rumblelabs/asset_sync)
+
+Fully compatible.
+
+### [wicked_pdf](https://github.com/mileszs/wicked_pdf)
+
+Fully compatible starting from version `0.8.0`.
+
+```ruby
+gem 'wicked_pdf', '>= 0.8.0'
+```
+
+<hr/>
+
+Please let me know if you have any problems with other gems, and I will either fix it, or make a note of the problem here.
+
+## Deployments
+
+### Capistrano
+
+`turbo-sprockets-rails3` should work out of the box with the latest version of Capistrano.
+
+### Heroku
+
+I've created a Heroku Buildpack for `turbo-sprockets-rails3` that keeps your assets cached between deploys, so you only need to recompile changed assets. It will automatically expire old assets that are no longer referenced by `manifest.yml` after 7 days, so your `public/assets` folder won't grow out of control.
+
+To create a new application on Heroku using this buildpack, you can run:
+
+```bash
+heroku create --buildpack https://github.com/ndbroadbent/heroku-buildpack-turbo-sprockets.git
+```
+
+To add the buildpack to an existing app, you can run:
+
+```bash
+heroku config:add BUILDPACK_URL=https://github.com/ndbroadbent/heroku-buildpack-turbo-sprockets.git
+```
+
+#### Compiling Assets on Your Local Machine
+
+You can also compile assets on your local machine, and commit the compiled assets. You might want to do this if your local machine is a lot faster than the Heroku VM, or if you also want to generate other files, such as static pages. When you push compiled assets to Heroku, it will automatically skip the `assets:precompile` task.
+
+I've automated this process in a Rake task for my own projects. The task creates a deployment repo at `tmp/heroku_deploy` so that you can keep working while deploying, and it also rebases and amends the assets commit to keep your repo's history from growing out of control. You can find the deploy task in a gist at https://gist.github.com/3802355. Save this file to `lib/tasks/deploy.rake`, and make sure you have added a `heroku` remote to your repo. You will now be able to run `rake deploy` to deploy your app to Heroku.
+
+#### Compiling Assets for a specific RAILS_ENV
+
+Supplying an RAILS_ENV to the precompile task will generate (and read from) an env specific sources manifest
+
+## Debugging
+
+If you would like to view debugging information in your terminal during the `assets:precompile` task, add the following lines to the bottom of `config/environments/production.rb`:
+
+```ruby
+config.log_level = :debug
+config.logger = Logger.new(STDOUT)
+```
+
+

data/Rakefile

@@ -0,0 +1,28 @@
+#!/usr/bin/env rake
+require 'rake/testtask'
+ENV["TEST_CORES"] = "1"
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+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_non_digest_generator.rb

@@ -0,0 +1,106 @@
+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
+      @digests = options.fetch(:digests, {})
+
+      # Parse digests from digests hash
+      @asset_digests = Hash[*@digests.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|
+        if File.basename(logical_path)[/[^\.]+/, 0] == 'index'
+          logical_path.sub!(/\/index\./, '.')
+        end
+        next unless compile_path?(logical_path)
+
+        if digest_path = @digests[logical_path]
+          abs_digest_path  = "#{@target}/#{digest_path}"
+          abs_logical_path = "#{@target}/#{logical_path}"
+
+          # Remove known digests from css & js
+          if abs_digest_path.match(/\.(?:js|css)$/)
+            mtime = File.mtime(abs_digest_path)
+
+            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.
+            # Ignore paths that have no digests, such as READMEs
+            unless !File.exist?(abs_digest_path) || abs_digest_path == abs_logical_path
+              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
+        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,39 @@
+module Sprockets
+  class UnprocessedAsset < AssetWithDependencies
+    def initialize(environment, logical_path, pathname)
+      super
+
+      @environment = environment
+      context = environment.context_class.new(environment, logical_path, pathname)
+      attributes = environment.attributes_for(pathname)
+      preprocessors = environment.preprocessors(content_type)
+
+      # Remove all postprocessors and engines except ERB to return unprocessed source file
+      allowed_engines = [Tilt::ERBTemplate]
+      processors = preprocessors + (allowed_engines & attributes.engines)
+
+      @source = context.evaluate(pathname, :processors => processors)
+
+      # If the source contains any '@import' directives, add Sass and Less processors.
+      # (@import is quite difficult to handle properly without processing.)
+      if @source.include?("@import")
+        # Process Sass and Less files, since @import is too tricky to handle properly.
+        allowed_engines << Sass::Rails::ScssTemplate if defined?(Sass::Rails::ScssTemplate)
+        allowed_engines << Sass::Rails::SassTemplate if defined?(Sass::Rails::SassTemplate)
+        allowed_engines << Less::Rails::LessTemplate if defined?(Less::Rails::LessTemplate)
+        processors = preprocessors + (allowed_engines & attributes.engines)
+        @source = context.evaluate(pathname, :processors => processors)
+      end
+
+      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