sprockets-rails 1.0.0 → 2.0.0.backport1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b54d7de577eca6df5b44639df6929423a10b7311
+  data.tar.gz: 4df8d48affeec6bb7d1f1b4243a1c58c02642ef1
+SHA512:
+  metadata.gz: e28cb27742cf4e57dfdce771577f6040391935b70565c53e8740da42587417f44d15fbdd7d36e34b7cc8dfb986cf6411b150791879bb78de374d1d1696ef6800
+  data.tar.gz: 2192f3965ac0b09a84255e2532965be55b47daf504f996c5695b1fa509586957ac625ab48039e39c7854faf48cf2ba8518be43db75f9799b20b87bea95e265c4

data/README.md

@@ -0,0 +1,155 @@
+# Sprockets Rails
+
+Provides Sprockets implementation for Rails 4.x (and beyond) Asset Pipeline.
+
+
+## Installation
+
+``` ruby
+gem 'sprockets-rails', :require => 'sprockets/railtie'
+```
+
+Or alternatively `require 'sprockets/railtie'` in your `config/application.rb` if you have Bundler auto-require disabled.
+
+
+## Usage
+
+
+### Rake task
+
+**`rake assets:precompile`**
+
+Deployment task that compiles any assets listed in `config.assets.precompile` to `public/assets`.
+
+**`rake assets:clean`**
+
+Only removes old assets (keeps the most recent 3 copies) from `public/assets`. Useful when doing rolling deploys that may still be serving old assets while the new ones are being compiled.
+
+**`rake assets:clobber`**
+
+Nuke `public/assets` and clear the Sprockets file system cache.
+
+#### Customize
+
+If the basic tasks don't do all that you need, it's straight forward to redefine them and replace them with something more specific to your app.
+
+You can also redefine the task with the built in task generator.
+
+``` ruby
+require 'sprockets/rails/task'
+Sprockets::Rails::Task.new do |t|
+  t.environment = lambda { Rails.application.assets }
+  t.assets = %w( application.js application.css )
+  t.keep = 5
+end
+```
+
+Each asset task will invoke `assets:environment` first. By default this loads the Rails environment. You can override this task to add or remove dependencies for your specific compilation environment.
+
+Also see [Sprockest::Rails::Task](https://github.com/josh/sprockets-rails/blob/master/lib/sprockets/rails/task.rb) and [Rake::SprocketsTask](https://github.com/sstephenson/sprockets/blob/master/lib/rake/sprocketstask.rb).
+
+
+### Initializer options
+
+**`config.assets.precompile`**
+
+Add additional assets to compile on deploy. Defaults to `application.js`, `application.css` and any other non-js/css file under `app/assets`.
+
+**`config.assets.paths`**
+
+Add additional load paths to this Array. Rails includes `app/assets` and `vendor/assets` for you already. Plugins might want to add their custom paths to to this.
+
+**`config.assets.version`**
+
+Set a custom cache buster string. Changing it will cause all assets to recompile on the next build.
+
+``` ruby
+config.assets.version = 'v1'
+# after installing a new plugin, change loads paths
+config.assets.version = 'v2'
+```
+
+**`config.assets.prefix`**
+
+Defaults to `/assets`. Changes the directory to compile assets to.
+
+**`config.assets.digest`**
+
+Link to undigest asset filenames. This option will eventually go away. Unless when `compile` is disabled.
+
+**`config.assets.debug`**
+
+Enable expanded asset debugging mode. Individual files will be served to make referencing filenames in the web console easier. This feature will eventually be deprecated and replaced by Source Maps in Sprockets 3.x.
+
+**`config.assets.compile`**
+
+Enables Sprockest compile environment. If disabled, `Rails.application.assets` will be unavailable to any ActionView helpers. View helpers will depend on assets being precompiled to `public/assets` in order to link to them. You can still access the environment by directly calling `Rails.application.assets`.
+
+**`config.assets.configure`**
+
+Invokes block with environment when the environment is initialized. Allows direct access to the environment instance and lets you lazily load libraries only needed for asset compiling.
+
+``` ruby
+config.assets.configure do |env|
+  env.js_compressor  = :uglify # or :closure, :yui
+  env.css_compressor = :sass   # or :yui
+
+  require 'my_processor'
+  env.register_preprocessor 'application/javascript', MyProcessor
+
+  env.logger = Rails.logger
+
+  env.cache = ActiveSupport::Cache::FileStore.new("tmp/cache/assets")
+end
+```
+
+
+## Complementary plugins
+
+The following plugins provide some extras for the Sprockets Asset Pipeline.
+
+* [coffee-rails](https://github.com/rails/coffee-rails)
+* [sass-rails](https://github.com/rails/sass-rails)
+
+**NOTE** That these plugins are optional. The core coffee-script, sass, less, uglify, (any many more) features are built into Sprockets itself. Many of these plugins only provide generators and extra helpers. You can probably get by without them.
+
+
+## Changes from Rails 3.x
+
+* Only compiles digest filenames. Static non-digest assets should simply live in public/.
+* Unmanaged asset paths and urls fallback to linking to public/. This should make it easier to work with both compiled assets and simple static assets. As a side effect, there will never be any "asset not precompiled errors" when linking to missing assets. They will just link to a public file which may or may not exist.
+* JS and CSS compressors must be explicitly set. Magic detection has been removed to avoid loading compressors in environments where you want to avoid loading any of the asset libraries. Assign `config.assets.js_compressor = :uglify` or `config.assets.css_compressor = :sass` for the standard compressors.
+* The manifest file is now in a JSON format. Since it lives in public/ by default, the initial filename is also randomized to obfuscate public access to the resource.
+* Two cleanup tasks. `rake assets:clean` is now a safe cleanup that only removes older assets that are no longer used. While `rake assets:clobber` nukes the entire `public/assets` directory and clears your filesystem cache. The clean task allows for rolling deploys that may still be linking to an old asset while the new assets are being built.
+
+
+## Contributing
+
+Usual bundler workflow.
+
+``` shell
+$ git clone https://github.com/rails/sprockets-rails.git
+$ cd sprockets-rails/
+$ bundle install
+$ bundle exec rake test
+```
+
+[![Build Status](https://secure.travis-ci.org/rails/sprockets-rails.png)](http://travis-ci.org/rails/sprockets-rails)
+
+
+## Releases
+
+sprockets-rails 2.x will primarily target sprockets 2.x. And future versions will target the corresponding sprockets release line.
+
+The minor and patch version will be updated according to [semver](http://semver.org/).
+
+* Any new APIs or config options that don't break compatibility will be in a minor release
+* Any time the sprockets depedency is bumped, there will be a new minor release
+* Simple bug fixes will be patch releases
+
+
+## License
+
+Copyright © 2012 Joshua Peek.
+
+Released under the MIT license. See `LICENSE` for details.

data/lib/sprockets/rails.rb

@@ -0,0 +1,3 @@
+if defined? Rails::Railtie
+  require 'sprockets/railtie'
+end

data/lib/sprockets/rails/helper.rb

@@ -0,0 +1,145 @@
+require 'action_view'
+require 'sprockets'
+require 'active_support/core_ext/class/attribute'
+
+module Sprockets
+  module Rails
+    module Helper
+      if defined? ActionView::Helpers::AssetUrlHelper
+        include ActionView::Helpers::AssetUrlHelper
+      else
+        require 'sprockets/rails/legacy_asset_tag_helper'
+        require 'sprockets/rails/legacy_asset_url_helper'
+        include LegacyAssetTagHelper
+        include LegacyAssetUrlHelper
+      end
+
+      VIEW_ACCESSORS = [:assets_environment, :assets_manifest,
+                        :assets_prefix, :digest_assets, :debug_assets]
+
+      def self.included(klass)
+        if klass < Sprockets::Context
+          klass.class_eval do
+            alias_method :assets_environment, :environment
+            def assets_manifest; end
+            class_attribute :config, :assets_prefix, :digest_assets
+          end
+        else
+          klass.class_attribute(*VIEW_ACCESSORS)
+        end
+      end
+
+      def self.extended(obj)
+        obj.class_eval do
+          attr_accessor(*VIEW_ACCESSORS)
+        end
+      end
+
+      def compute_asset_path(path, options = {})
+        if digest_path = asset_digest_path(path)
+          path = digest_path if digest_assets
+          path += "?body=1" if options[:debug]
+          File.join(assets_prefix || "/", path)
+        else
+          super
+        end
+      end
+
+      # Get digest for asset path.
+      #
+      # path    - String path
+      # options - Hash options
+      #
+      # Returns String Hex digest or nil if digests are disabled.
+      def asset_digest(path, options = {})
+        return unless digest_assets
+
+        if digest_path = asset_digest_path(path, options)
+          digest_path[/-(.+)\./, 1]
+        end
+      end
+
+      # Expand asset path to digested form.
+      #
+      # path    - String path
+      # options - Hash options
+      #
+      # Returns String path or nil if no asset was found.
+      def asset_digest_path(path, options = {})
+        if manifest = assets_manifest
+          if digest_path = manifest.assets[path]
+            return digest_path
+          end
+        end
+
+        if environment = assets_environment
+          if asset = environment[path]
+            return asset.digest_path
+          end
+        end
+      end
+
+      # Override javascript tag helper to provide debugging support.
+      #
+      # Eventually will be deprecated and replaced by source maps.
+      def javascript_include_tag(*sources)
+        options = sources.extract_options!.stringify_keys
+
+        if request_debug_assets?
+          sources.map { |source|
+            if asset = lookup_asset_for_path(source, :type => :javascript)
+              asset.to_a.map do |a|
+                super(path_to_javascript(a.logical_path, :debug => true), options)
+              end
+            else
+              super(source, options)
+            end
+          }.flatten.uniq.join("\n").html_safe
+        else
+          sources.push(options)
+          super(*sources)
+        end
+      end
+
+      # Override stylesheet tag helper to provide debugging support.
+      #
+      # Eventually will be deprecated and replaced by source maps.
+      def stylesheet_link_tag(*sources)
+        options = sources.extract_options!.stringify_keys
+
+        if request_debug_assets?
+          sources.map { |source|
+            if asset = lookup_asset_for_path(source, :type => :stylesheet)
+              asset.to_a.map do |a|
+                super(path_to_stylesheet(a.logical_path, :debug => true), options)
+              end
+            else
+              super(source, options)
+            end
+          }.flatten.uniq.join("\n").html_safe
+        else
+          sources.push(options)
+          super(*sources)
+        end
+      end
+
+      protected
+        # Enable split asset debugging. Eventually will be deprecated
+        # and replaced by source maps in Sprockets 3.x.
+        def request_debug_assets?
+          debug_assets || (defined?(controller) && controller && params[:debug_assets])
+        end
+
+        # Internal method to support multifile debugging. Will
+        # eventually be removed w/ Sprockets 3.x.
+        def lookup_asset_for_path(path, options = {})
+          return unless env = assets_environment
+          path = path.to_s
+          if extname = compute_asset_extname(path, options)
+            path = "#{path}#{extname}"
+          end
+          env[path]
+        end
+    end
+  end
+end

data/lib/sprockets/rails/legacy_asset_tag_helper.rb

@@ -0,0 +1,32 @@
+require 'sprockets'
+
+module Sprockets
+  module Rails
+    # Backports of AssetTagHelper methods for Rails 2.x and 3.x.
+    module LegacyAssetTagHelper
+      include ActionView::Helpers::TagHelper
+
+      def javascript_include_tag(*sources)
+        options = sources.extract_options!.stringify_keys
+        sources.uniq.map { |source|
+          tag_options = {
+            "src" => path_to_javascript(source)
+          }.merge(options)
+          content_tag(:script, "", tag_options)
+        }.join("\n").html_safe
+      end
+
+      def stylesheet_link_tag(*sources)
+        options = sources.extract_options!.stringify_keys
+        sources.uniq.map { |source|
+          tag_options = {
+            "rel" => "stylesheet",
+            "media" => "screen",
+            "href" => path_to_stylesheet(source)
+          }.merge(options)
+          tag(:link, tag_options)
+        }.join("\n").html_safe
+      end
+    end
+  end
+end

data/lib/sprockets/rails/legacy_asset_url_helper.rb

@@ -0,0 +1,130 @@
+require 'sprockets'
+
+module Sprockets
+  module Rails
+    # Backports of AssetUrlHelper methods for Rails 2.x and 3.x.
+    module LegacyAssetUrlHelper
+      URI_REGEXP = %r{^[-a-z]+://|^(?:cid|data):|^//}
+
+      def asset_path(source, options = {})
+        source = source.to_s
+        return "" unless source.present?
+        return source if source =~ URI_REGEXP
+
+        tail, source = source[/([\?#].+)$/], source.sub(/([\?#].+)$/, '')
+
+        if extname = compute_asset_extname(source, options)
+          source = "#{source}#{extname}"
+        end
+
+        if source[0] != ?/
+          source = compute_asset_path(source, options)
+        end
+
+        relative_url_root = (defined?(config.relative_url_root) && config.relative_url_root) ||
+          (respond_to?(:request) && request.try(:script_name))
+        if relative_url_root
+          source = "#{relative_url_root}#{source}" unless source.starts_with?("#{relative_url_root}/")
+        end
+
+        if host = compute_asset_host(source, options)
+          source = "#{host}#{source}"
+        end
+
+        "#{source}#{tail}"
+      end
+      alias_method :path_to_asset, :asset_path
+
+      ASSET_EXTENSIONS = {
+        :javascript => '.js',
+        :stylesheet => '.css'
+      }
+
+      def compute_asset_extname(source, options = {})
+        return if options[:extname] == false
+        extname = options[:extname] || ASSET_EXTENSIONS[options[:type]]
+        extname if extname && File.extname(source) != extname
+      end
+
+      ASSET_PUBLIC_DIRECTORIES = {
+        :audio      => '/audios',
+        :font       => '/fonts',
+        :image      => '/images',
+        :javascript => '/javascripts',
+        :stylesheet => '/stylesheets',
+        :video      => '/videos'
+      }
+
+      def compute_asset_path(source, options = {})
+        dir = ASSET_PUBLIC_DIRECTORIES[options[:type]] || ""
+        File.join(dir, source)
+      end
+
+      def compute_asset_host(source = "", options = {})
+        request = self.request if respond_to?(:request)
+
+        if defined? config
+          host = config.asset_host
+        elsif defined? ActionController::Base.asset_host
+          host = ActionController::Base.asset_host
+        end
+
+        host ||= request.base_url if request && options[:protocol] == :request
+        return unless host
+
+        if host.respond_to?(:call)
+          arity = host.respond_to?(:arity) ? host.arity : host.method(:call).arity
+          args = [source]
+          args << request if request && (arity > 1 || arity < 0)
+          host = host.call(*args)
+        elsif host =~ /%d/
+          host = host % (Zlib.crc32(source) % 4)
+        end
+
+        if host =~ URI_REGEXP
+          host
+        else
+          protocol = options[:protocol] || (request ? :request : :relative)
+          case protocol
+          when :relative
+            "//#{host}"
+          when :request
+            "#{request.protocol}#{host}"
+          else
+            "#{protocol}://#{host}"
+          end
+        end
+      end
+
+      def javascript_path(source, options = {})
+        path_to_asset(source, {:type => :javascript}.merge(options))
+      end
+      alias_method :path_to_javascript, :javascript_path
+
+      def stylesheet_path(source, options = {})
+        path_to_asset(source, {:type => :stylesheet}.merge(options))
+      end
+      alias_method :path_to_stylesheet, :stylesheet_path
+
+      def image_path(source, options = {})
+        path_to_asset(source, {:type => :image}.merge(options))
+      end
+      alias_method :path_to_image, :image_path
+
+      def video_path(source, options = {})
+        path_to_asset(source, {:type => :video}.merge(options))
+      end
+      alias_method :path_to_video, :video_path
+
+      def audio_path(source, options = {})
+        path_to_asset(source, {:type => :audio}.merge(options))
+      end
+      alias_method :path_to_audio, :audio_path
+
+      def font_path(source, options = {})
+        path_to_asset(source, {:type => :font}.merge(options))
+      end
+      alias_method :path_to_font, :font_path
+    end
+  end
+end