Hello community, here is the log from the commit of package rubygem-sprockets-rails for openSUSE:Factory checked in at 2016-04-28 16:52:53 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/rubygem-sprockets-rails (Old) and /work/SRC/openSUSE:Factory/.rubygem-sprockets-rails.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "rubygem-sprockets-rails" Changes: -------- --- /work/SRC/openSUSE:Factory/rubygem-sprockets-rails/rubygem-sprockets-rails.changes 2015-09-19 09:54:45.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.rubygem-sprockets-rails.new/rubygem-sprockets-rails.changes 2016-04-28 16:53:03.000000000 +0200 @@ -1,0 +2,30 @@ +Thu Mar 3 05:30:36 UTC 2016 - coolo@suse.com + +- updated to version 3.0.4 + no changelog found + +------------------------------------------------------------------- +Wed Mar 2 05:38:23 UTC 2016 - coolo@suse.com + +- updated to version 3.0.3 + no changelog found + +------------------------------------------------------------------- +Wed Feb 24 05:44:53 UTC 2016 - coolo@suse.com + +- updated to version 3.0.2 + no changelog found + +------------------------------------------------------------------- +Fri Jan 29 05:35:07 UTC 2016 - coolo@suse.com + +- updated to version 3.0.1 + no changelog found + +------------------------------------------------------------------- +Fri Dec 18 05:39:37 UTC 2015 - coolo@suse.com + +- updated to version 3.0.0 + no changelog found + +------------------------------------------------------------------- Old: ---- sprockets-rails-2.3.3.gem New: ---- sprockets-rails-3.0.4.gem ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ rubygem-sprockets-rails.spec ++++++ --- /var/tmp/diff_new_pack.7K2CNK/_old 2016-04-28 16:53:04.000000000 +0200 +++ /var/tmp/diff_new_pack.7K2CNK/_new 2016-04-28 16:53:04.000000000 +0200 @@ -1,7 +1,7 @@ # # spec file for package rubygem-sprockets-rails # -# Copyright (c) 2015 SUSE LINUX GmbH, Nuernberg, Germany. +# Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -24,13 +24,13 @@ # Name: rubygem-sprockets-rails -Version: 2.3.3 +Version: 3.0.4 Release: 0 %define mod_name sprockets-rails %define mod_full_name %{mod_name}-%{version} BuildRoot: %{_tmppath}/%{name}-%{version}-build +BuildRequires: %{ruby >= 1.9.3} BuildRequires: %{rubygem gem2rpm} -BuildRequires: %{ruby} BuildRequires: ruby-macros >= 5 Url: https://github.com/rails/sprockets-rails Source: http://rubygems.org/gems/%{mod_full_name}.gem @@ -48,7 +48,7 @@ %install %gem_install \ - --doc-files="LICENSE README.md" \ + --doc-files="MIT-LICENSE README.md" \ -f %gem_packages ++++++ sprockets-rails-2.3.3.gem -> sprockets-rails-3.0.4.gem ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/LICENSE new/LICENSE --- old/LICENSE 2015-09-08 03:29:27.000000000 +0200 +++ new/LICENSE 1970-01-01 01:00:00.000000000 +0100 @@ -1,20 +0,0 @@ -Copyright (c) 2014 Joshua Peek - -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. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/MIT-LICENSE new/MIT-LICENSE --- old/MIT-LICENSE 1970-01-01 01:00:00.000000000 +0100 +++ new/MIT-LICENSE 2016-03-02 18:18:46.000000000 +0100 @@ -0,0 +1,20 @@ +Copyright (c) 2014-2016 Joshua Peek + +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. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/README.md new/README.md --- old/README.md 2015-09-08 03:29:27.000000000 +0200 +++ new/README.md 2016-03-02 18:18:46.000000000 +0100 @@ -27,7 +27,7 @@ **`rake assets:clobber`** -Nuke `public/assets` and clear the Sprockets file system cache. +Nuke `public/assets`. #### Customize @@ -37,11 +37,6 @@ ``` ruby require 'sprockets/rails/task' -# clean the old tasks -Rake::Task["assets:environment"].clear -Rake::Task["assets:precompile"].clear -Rake::Task["assets:clean"].clear -Rake::Task["assets:clobber"].clear Sprockets::Rails::Task.new(Rails.application) do |t| t.environment = lambda { Rails.application.assets } t.assets = %w( application.js application.css ) @@ -51,7 +46,7 @@ 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 [Sprockets::Rails::Task](https://github.com/rails/sprockets-rails/blob/master/lib/sprockets/rails/tas...) and [Rake::SprocketsTask](https://github.com/sstephenson/sprockets/blob/master/lib/rake/sprocketstask....). +Also see [Sprockets::Rails::Task](https://github.com/rails/sprockets-rails/blob/master/lib/sprockets/rails/tas...) and [Rake::SprocketsTask](https://github.com/rails/sprockets/blob/master/lib/rake/sprocketstask.rb). ### Initializer options @@ -60,10 +55,6 @@ 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.raise_runtime_errors`** - -Set to `true` to enable additional runtime error checking. Recommended in the `development` environment to minimize unexpected behavior when deploying to `production`. - **`config.assets.paths`** Add additional load paths to this Array. Rails includes `app/assets`, `lib/assets` and `vendor/assets` for you already. Plugins might want to add their custom paths to this. @@ -83,13 +74,9 @@ Defaults to `/assets`. Changes the directory to compile assets to. -**`config.assets.manifest`** - -Defines the full path to be used for the asset precompiler's manifest file. Defaults to a randomly-generated filename in the `config.assets.prefix` directory within the public folder. - **`config.assets.digest`** -Link to undigest asset filenames. This option will eventually go away. Unless when `compile` is disabled. +When enabled, fingerprints will be added to asset filenames. **`config.assets.debug`** @@ -97,7 +84,7 @@ **`config.assets.compile`** -Enables Sprockets 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`. +Enables Sprockets compile environment. If disabled, `Rails.application.assets` will be `nil` to prevent inadvertent compilation calls. View helpers will depend on assets being precompiled to `public/assets` in order to link to them. Initializers expecting `Rails.application.assets` during boot should be accessing the environment in a `config.assets.configure` block. See below. **`config.assets.configure`** @@ -105,18 +92,34 @@ ``` ruby config.assets.configure do |env| - env.js_compressor = :uglify # or :closure, :yui + env.js_compressor = :uglifier # 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 ``` +**`config.assets.resolve_with`** + +A list of `:environment` and `:manifest` symbols that defines the order that +we try to find assets: manifest first, environment second? Manifest only? + +By default, we check the manifest first if asset digests are enabled and debug +is not enabled, then we check the environment if compiling is enabled: +``` +# Dev where debug is true, or digests are disabled +%i[ environment ] + +# Dev default, or production with compile enabled. +%i[ manifest environment ] + +# Production default. +%i[ manifest ] +``` +If the resolver list is empty (e.g. if debug is true and compile is false), the standard rails public path resolution will be used. ## Complementary plugins @@ -132,29 +135,33 @@ * 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. +* 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 = :uglifier` 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. * `config.assets.manifest` (if used) must now include the manifest filename, e.g. `Rails.root.join('config/manifest.json')`. It cannot be a directory. * 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. +## Experimental -## Contributing +### [SRI](http://www.w3.org/TR/SRI/) support -Usual bundler workflow. +Sprockets 3.x adds experimental support for subresource integrity checks. The spec is still evolving and the API may change in backwards incompatible ways. -``` shell -$ git clone https://github.com/rails/sprockets-rails.git -$ cd sprockets-rails/ -$ bundle install -$ bundle exec rake test +``` ruby +javascript_include_tag :application, integrity: true +# => "<script src="/assets/application.js" integrity="sha256-TvVUHzSfftWg1rcfL6TIJ0XKEGrgLyEq6lEpcmrG9qs="></script>" ``` -[![Build Status](https://secure.travis-ci.org/rails/sprockets-rails.png)](http://travis-ci.org/rails/sprockets-rails) +## Contributing to Sprockets Rails + +Sprockets Rails is work of many contributors. You're encouraged to submit pull requests, propose +features and discuss issues. + +See [CONTRIBUTING](CONTRIBUTING.md). ## Releases -sprockets-rails 2.x will primarily target sprockets 2.x with future compatibility for 3.x. Consider upgrading to sprockets-rails 3.x to take full advantage of 3.x features. +sprockets-rails 3.x will primarily target sprockets 3.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/). @@ -162,9 +169,12 @@ * Any time the sprockets dependency is bumped, there will be a new minor release * Simple bug fixes will be patch releases - ## License -Copyright © 2014 Joshua Peek. +Sprockets Rails is released under the [MIT License](MIT-LICENSE). + +## Code Status -Released under the MIT license. See `LICENSE` for details. +* [![Travis CI](https://api.travis-ci.org/rails/sprockets-rails.svg)](http://travis-ci.org/rails/sprockets-rails) +* [![Gem Version](https://badge.fury.io/rb/sprockets-rails.svg)](http://badge.fury.io/rb/sprockets-rails) +* [![Dependencies](https://gemnasium.com/rails/sprockets-rails.svg)](https://gemnasium.com/rails/sprockets-rails) Files old/checksums.yaml.gz and new/checksums.yaml.gz differ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/sprockets/rails/context.rb new/lib/sprockets/rails/context.rb --- old/lib/sprockets/rails/context.rb 1970-01-01 01:00:00.000000000 +0100 +++ new/lib/sprockets/rails/context.rb 2016-03-02 18:18:46.000000000 +0100 @@ -0,0 +1,48 @@ +require 'action_view' +require 'sprockets' + +module Sprockets + module Rails + module Context + include ActionView::Helpers::AssetUrlHelper + include ActionView::Helpers::AssetTagHelper + + def self.included(klass) + klass.class_eval do + class_attribute :config, :assets_prefix, :digest_assets + end + end + + def compute_asset_path(path, options = {}) + @dependencies << 'actioncontroller-asset-url-config' + + begin + asset_uri = resolve(path) + rescue FileNotFound + # TODO: eh, we should be able to use a form of locate that returns + # nil instead of raising an exception. + end + + if asset_uri + asset = link_asset(path) + digest_path = asset.digest_path + path = digest_path if digest_assets + File.join(assets_prefix || "/", path) + else + super + end + end + end + end + + register_dependency_resolver 'actioncontroller-asset-url-config' do |env| + config = env.context_class.config + [config.relative_url_root, + (config.asset_host unless config.asset_host.respond_to?(:call))] + end + + # fallback to the default pipeline when using Sprockets 3.x + unless config[:pipelines].include? :debug + register_pipeline :debug, config[:pipelines][:default] + end +end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/sprockets/rails/helper.rb new/lib/sprockets/rails/helper.rb --- old/lib/sprockets/rails/helper.rb 2015-09-08 03:29:27.000000000 +0200 +++ new/lib/sprockets/rails/helper.rb 2016-03-02 18:18:46.000000000 +0100 @@ -1,128 +1,118 @@ require 'action_view' require 'sprockets' require 'active_support/core_ext/class/attribute' +require 'sprockets/rails/utils' module Sprockets module Rails module Helper - class << self - attr_accessor :precompile, :assets, :raise_runtime_errors - end - - def precompile - Sprockets::Rails::Helper.precompile - end - - def assets - Sprockets::Rails::Helper.assets - end - - def raise_runtime_errors - Sprockets::Rails::Helper.raise_runtime_errors - end - - class AssetFilteredError < StandardError + class AssetNotPrecompiled < StandardError + include Sprockets::Rails::Utils def initialize(source) - msg = "Asset filtered out and will not be served: " << - "add `Rails.application.config.assets.precompile += %w( #{source} )` " << - "to `config/initializers/assets.rb` and restart your server" - super(msg) - end - end - - class AbsoluteAssetPathError < ArgumentError - def initialize(bad_path, good_path, prefix) - msg = "Asset names passed to helpers should not include the #{prefix.inspect} prefix. " << - "Instead of #{bad_path.inspect}, use #{good_path.inspect}" + msg = + if using_sprockets4? + "Asset `#{source}` was not declared to be precompiled in production.\n" + + "Declare links to your assets in `assets/config/manifest.js`.\n" + + "Examples:\n" + + "`//= link ../javascripts/application.js`\n" + + "`//= link_directory ../javascripts .js`\n" + + "`//= link_directory ../stylesheets .css`\n" + + "`//= link_tree ../javascripts .js`\n" + + "`//= link_tree ../images`\n" + else + "Asset was not declared to be precompiled in production.\n" + + "Add `Rails.application.config.assets.precompile += " + + "%w( #{source} )` to `config/initializers/assets.rb` and " + + "restart your server" + end super(msg) end end - if defined? ActionView::Helpers::AssetUrlHelper - include ActionView::Helpers::AssetUrlHelper - include ActionView::Helpers::AssetTagHelper - 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] + include ActionView::Helpers::AssetUrlHelper + include ActionView::Helpers::AssetTagHelper + include Sprockets::Rails::Utils + + VIEW_ACCESSORS = [ + :assets_environment, :assets_manifest, + :assets_precompile, :precompiled_asset_checker, + :assets_prefix, :digest_assets, :debug_assets, + :resolve_assets_with + ] 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, :debug_assets + klass.class_attribute(*VIEW_ACCESSORS) + + klass.class_eval do + remove_method :assets_environment + def assets_environment + if instance_variable_defined?(:@assets_environment) + @assets_environment = @assets_environment.cached + elsif env = self.class.assets_environment + @assets_environment = env.cached + else + nil + end end - else - klass.class_attribute(*VIEW_ACCESSORS) end end def self.extended(obj) obj.class_eval do attr_accessor(*VIEW_ACCESSORS) + + remove_method :assets_environment + def assets_environment + if env = @assets_environment + @assets_environment = env.cached + else + nil + end + end end end def compute_asset_path(path, options = {}) - # Check if we are inside Sprockets context before calling check_dependencies!. - check_dependencies!(path) if defined?(depend_on) + debug = options[:debug] - if digest_path = asset_digest_path(path) - path = digest_path if digest_assets - path += "?body=1" if options[:debug] - File.join(assets_prefix || "/", path) + if asset_path = resolve_asset_path(path, debug) + File.join(assets_prefix || "/", legacy_debug_path(asset_path, debug)) else super end end - # Computes the full URL to a asset in the public directory. This - # method checks for errors before returning path. - def asset_path(source, options = {}) - unless options[:debug] - check_errors_for(source, options) + # Resolve the asset path against the Sprockets manifest or environment. + # Returns nil if it's an asset we don't know about. + def resolve_asset_path(path, allow_non_precompiled = false) #:nodoc: + resolve_asset do |resolver| + resolver.asset_path path, digest_assets, allow_non_precompiled end - super(source, options) end - alias :path_to_asset :asset_path - # Get digest for asset path. + # Expand asset path to digested form. # # 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] + # Returns String path or nil if no asset was found. + def asset_digest_path(path, options = {}) + resolve_asset do |resolver| + resolver.digest_path path, options[:debug] end end - # Expand asset path to digested form. + # Experimental: Get integrity for asset path. # # 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 + # Returns String integrity attribute or nil if no asset was found. + def asset_integrity(path, options = {}) + path = path_with_extname(path, options) - if environment = assets_environment - if asset = environment[path] - return asset.digest_path - end + resolve_asset do |resolver| + resolver.integrity path end end @@ -131,21 +121,27 @@ # Eventually will be deprecated and replaced by source maps. def javascript_include_tag(*sources) options = sources.extract_options!.stringify_keys + integrity = compute_integrity?(options) if options["debug"] != false && request_debug_assets? sources.map { |source| - check_errors_for(source, :type => :javascript) - 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) + if asset = lookup_debug_asset(source, type: :javascript) + if asset.respond_to?(:to_a) + asset.to_a.map do |a| + super(path_to_javascript(a.logical_path, debug: true), options) + end + else + super(path_to_javascript(asset.logical_path, debug: true), options) end else super(source, options) end }.flatten.uniq.join("\n").html_safe else - sources.push(options) - super(*sources) + sources.map { |source| + options = options.merge('integrity' => asset_integrity(source, type: :javascript)) if integrity + super source, options + }.join("\n").html_safe end end @@ -154,81 +150,205 @@ # Eventually will be deprecated and replaced by source maps. def stylesheet_link_tag(*sources) options = sources.extract_options!.stringify_keys + integrity = compute_integrity?(options) + if options["debug"] != false && request_debug_assets? sources.map { |source| - check_errors_for(source, :type => :stylesheet) - 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) + if asset = lookup_debug_asset(source, type: :stylesheet) + if asset.respond_to?(:to_a) + asset.to_a.map do |a| + super(path_to_stylesheet(a.logical_path, debug: true), options) + end + else + super(path_to_stylesheet(asset.logical_path, debug: true), options) end else super(source, options) end }.flatten.uniq.join("\n").html_safe else - sources.push(options) - super(*sources) + sources.map { |source| + options = options.merge('integrity' => asset_integrity(source, type: :stylesheet)) if integrity + super source, options + }.join("\n").html_safe end end protected - # Ensures the asset is included in the dependencies list. - def check_dependencies!(dep) - depend_on(dep) - depend_on_asset(dep) - rescue Sprockets::FileNotFound + # This is awkward: `integrity` is a boolean option indicating whether + # we want to include or omit the subresource integrity hash, but the + # options hash is also passed through as literal tag attributes. + # That means we have to delete the shortcut boolean option so it + # doesn't bleed into the tag attributes, but also check its value if + # it's boolean-ish. + def compute_integrity?(options) + if secure_subresource_integrity_context? + case options['integrity'] + when nil, false, true + options.delete('integrity') == true + end + else + options.delete 'integrity' + false + end end - # Raise errors when source is not in the precompiled list, or - # incorrectly contains the assets_prefix. - def check_errors_for(source, options) - return unless self.raise_runtime_errors + # Only serve integrity metadata for HTTPS requests: + # http://www.w3.org/TR/SRI/#non-secure-contexts-remain-non-secure + def secure_subresource_integrity_context? + respond_to?(:request) && self.request && self.request.ssl? + end - source = source.to_s - return if source.blank? || source =~ URI_REGEXP + # 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]) + rescue # FIXME: what exactly are we rescuing? + false + end - asset = lookup_asset_for_path(source, options) + # Internal method to support multifile debugging. Will + # eventually be removed w/ Sprockets 3.x. + def lookup_debug_asset(path, options = {}) + path = path_with_extname(path, options) - if asset && asset_needs_precompile?(asset.logical_path, asset.pathname.to_s) - raise AssetFilteredError.new(asset.logical_path) + resolve_asset do |resolver| + resolver.find_debug_asset path end + end + + # compute_asset_extname is in AV::Helpers::AssetUrlHelper + def path_with_extname(path, options) + path = path.to_s + "#{path}#{compute_asset_extname(path, options)}" + end - full_prefix = File.join(self.assets_prefix || "/", '') - if !asset && source.start_with?(full_prefix) - short_path = source[full_prefix.size, source.size] - if lookup_asset_for_path(short_path, options) - raise AbsoluteAssetPathError.new(source, short_path, full_prefix) + # Try each asset resolver and return the first non-nil result. + def resolve_asset + asset_resolver_strategies.detect do |resolver| + if result = yield(resolver) + break result end end end - # Returns true when an asset will not be available after precompile is run - def asset_needs_precompile?(source, filename) - if assets_environment && assets_environment.send(:matches_filter, precompile || [], source, filename) - false + # List of resolvers in `config.assets.resolve_with` order. + def asset_resolver_strategies + @asset_resolver_strategies ||= + Array(resolve_assets_with).map do |name| + HelperAssetResolvers[name].new(self) + end + end + + # Append ?body=1 if debug is on and we're on old Sprockets. + def legacy_debug_path(path, debug) + if debug && !using_sprockets4? + "#{path}?body=1" else - true + path end end + end - # 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]) - rescue - return false + # Use a separate module since Helper is mixed in and we needn't pollute + # the class namespace with our internals. + module HelperAssetResolvers #:nodoc: + def self.[](name) + case name + when :manifest + Manifest + when :environment + Environment + else + raise ArgumentError, "Unrecognized asset resolver: #{name.inspect}. Expected :manifest or :environment" end + 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}" + class Manifest #:nodoc: + def initialize(view) + @manifest = view.assets_manifest + raise ArgumentError, 'config.assets.resolve_with includes :manifest, but app.assets_manifest is nil' unless @manifest + end + + def asset_path(path, digest, allow_non_precompiled = false) + if digest + digest_path path, allow_non_precompiled + end + end + + def digest_path(path, allow_non_precompiled = false) + @manifest.assets[path] + end + + def integrity(path) + if meta = metadata(path) + meta["integrity"] end - env[path] end + + def find_debug_asset(path) + nil + end + + private + def metadata(path) + if digest_path = digest_path(path) + @manifest.files[digest_path] + end + end + end + + class Environment #:nodoc: + def initialize(view) + raise ArgumentError, 'config.assets.resolve_with includes :environment, but app.assets is nil' unless view.assets_environment + @env = view.assets_environment + @precompiled_asset_checker = view.precompiled_asset_checker + end + + def asset_path(path, digest, allow_non_precompiled = false) + # Digests enabled? Do the work to calculate the full asset path. + if digest + digest_path path, allow_non_precompiled + + # Otherwise, ask the Sprockets environment whether the asset exists + # and check whether it's also precompiled for production deploys. + elsif asset = find_asset(path) + raise_unless_precompiled_asset asset.logical_path unless allow_non_precompiled + path + end + end + + def digest_path(path, allow_non_precompiled = false) + if asset = find_asset(path) + raise_unless_precompiled_asset asset.logical_path unless allow_non_precompiled + asset.digest_path + end + end + + def integrity(path) + find_asset(path).try :integrity + end + + def find_debug_asset(path) + if asset = find_asset(path, pipeline: :debug) + raise_unless_precompiled_asset asset.logical_path.sub('.debug', '') + asset + end + end + + private + def find_asset(path, options = {}) + @env[path, options] + end + + def precompiled?(path) + @precompiled_asset_checker.call path + end + + def raise_unless_precompiled_asset(path) + raise Helper::AssetNotPrecompiled.new(path) unless precompiled?(path) + end + end end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/sprockets/rails/legacy_asset_tag_helper.rb new/lib/sprockets/rails/legacy_asset_tag_helper.rb --- old/lib/sprockets/rails/legacy_asset_tag_helper.rb 2015-09-08 03:29:27.000000000 +0200 +++ new/lib/sprockets/rails/legacy_asset_tag_helper.rb 1970-01-01 01:00:00.000000000 +0100 @@ -1,32 +0,0 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/sprockets/rails/legacy_asset_url_helper.rb new/lib/sprockets/rails/legacy_asset_url_helper.rb --- old/lib/sprockets/rails/legacy_asset_url_helper.rb 2015-09-08 03:29:27.000000000 +0200 +++ new/lib/sprockets/rails/legacy_asset_url_helper.rb 1970-01-01 01:00:00.000000000 +0100 @@ -1,133 +0,0 @@ -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 - 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 - - def asset_url(source, options = {}) - path_to_asset(source, options.merge(:protocol => :request)) - end - - 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/sprockets/rails/route_wrapper.rb new/lib/sprockets/rails/route_wrapper.rb --- old/lib/sprockets/rails/route_wrapper.rb 1970-01-01 01:00:00.000000000 +0100 +++ new/lib/sprockets/rails/route_wrapper.rb 2016-03-02 18:18:46.000000000 +0100 @@ -0,0 +1,23 @@ +module Sprockets + module Rails + module RouteWrapper + + def internal_assets_path? + path =~ %r{\A#{self.class.assets_prefix}\z} + end + + def internal? + super || internal_assets_path? + end + + def self.included(klass) + klass.class_eval do + def internal_with_sprockets? + internal_without_sprockets? || internal_assets_path? + end + alias_method_chain :internal?, :sprockets + end + end + end + end +end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/sprockets/rails/task.rb new/lib/sprockets/rails/task.rb --- old/lib/sprockets/rails/task.rb 2015-09-08 03:29:27.000000000 +0200 +++ new/lib/sprockets/rails/task.rb 2016-03-02 18:18:46.000000000 +0100 @@ -16,7 +16,9 @@ def environment if app - app.assets + # Use initialized app.assets or force build an environment if + # config.assets.compile is disabled + app.assets || Sprockets::Railtie.build_environment(app) else super end @@ -24,7 +26,8 @@ def output if app - File.join(app.root, 'public', app.config.assets.prefix) + config = app.config + File.join(config.paths['public'].first, config.assets.prefix) else super end @@ -46,17 +49,12 @@ end end - def cache_path - if app - "#{app.config.root}/tmp/cache/assets" - else - @cache_path - end - end - attr_writer :cache_path - def define namespace :assets do + %w( environment precompile clean clobber ).each do |task| + Rake::Task[task].clear if Rake::Task.task_defined?(task) + end + # Override this task change the loaded dependencies desc "Load asset compile environment" task :environment do @@ -73,9 +71,8 @@ desc "Remove old compiled assets" task :clean, [:keep] => :environment do |t, args| - keep = Integer(args.keep || 2) with_logger do - manifest.clean(keep) + manifest.clean(Integer(args.keep || self.keep)) end end @@ -83,7 +80,6 @@ task :clobber => :environment do with_logger do manifest.clobber - rm_rf cache_path if cache_path end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/sprockets/rails/utils.rb new/lib/sprockets/rails/utils.rb --- old/lib/sprockets/rails/utils.rb 1970-01-01 01:00:00.000000000 +0100 +++ new/lib/sprockets/rails/utils.rb 2016-03-02 18:18:46.000000000 +0100 @@ -0,0 +1,11 @@ +require 'sprockets' + +module Sprockets + module Rails + module Utils + def using_sprockets4? + Gem::Version.new(Sprockets::VERSION) >= Gem::Version.new('4.x') + end + end + end +end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/sprockets/rails/version.rb new/lib/sprockets/rails/version.rb --- old/lib/sprockets/rails/version.rb 2015-09-08 03:29:27.000000000 +0200 +++ new/lib/sprockets/rails/version.rb 2016-03-02 18:18:46.000000000 +0100 @@ -1,5 +1,5 @@ module Sprockets module Rails - VERSION = "2.3.3" + VERSION = "3.0.4" end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/sprockets/railtie.rb new/lib/sprockets/railtie.rb --- old/lib/sprockets/railtie.rb 2015-09-08 03:29:27.000000000 +0200 +++ new/lib/sprockets/railtie.rb 2016-03-02 18:18:46.000000000 +0100 @@ -2,9 +2,13 @@ require 'rails/railtie' require 'action_controller/railtie' require 'active_support/core_ext/module/remove_method' +require 'active_support/core_ext/numeric/bytes' require 'sprockets' +require 'sprockets/rails/context' require 'sprockets/rails/helper' +require 'sprockets/rails/route_wrapper' require 'sprockets/rails/version' +require 'set' module Rails class Application @@ -19,37 +23,40 @@ remove_possible_method :assets= # Returns Sprockets::Environment for app config. - def assets - @assets ||= Sprockets::Environment.new(root.to_s) do |env| - env.version = ::Rails.env + attr_accessor :assets - path = "#{config.root}/tmp/cache/assets/#{::Rails.env}" - env.cache = Sprockets::Cache::FileStore.new(path) + # Returns Sprockets::Manifest for app config. + attr_accessor :assets_manifest - env.context_class.class_eval do - include ::Sprockets::Rails::Helper - end + # Called from asset helpers to alert you if you reference an asset URL that + # isn't precompiled and hence won't be available in production. + def asset_precompiled?(logical_path) + if precompiled_assets.include?(logical_path) + true + elsif !config.cache_classes + # Check to see if precompile list has been updated + precompiled_assets(true).include?(logical_path) + else + false end end - attr_writer :assets - # Returns Sprockets::Manifest for app config. - attr_accessor :assets_manifest + # Lazy-load the precompile list so we don't cause asset compilation at app + # boot time, but ensure we cache the list so we don't recompute it for each + # request or test case. + def precompiled_assets(clear_cache = false) + @precompiled_assets = nil if clear_cache + @precompiled_assets ||= assets_manifest.find(config.assets.precompile).map(&:logical_path).to_set + end end class Engine < Railtie # Skip defining append_assets_path on Rails <= 4.2 unless initializers.find { |init| init.name == :append_assets_path } initializer :append_assets_path, :group => :all do |app| - if paths["app/assets"].respond_to?(:existent_directories) - app.config.assets.paths.unshift(*paths["vendor/assets"].existent_directories) - app.config.assets.paths.unshift(*paths["lib/assets"].existent_directories) - app.config.assets.paths.unshift(*paths["app/assets"].existent_directories) - else - app.config.assets.paths.unshift(*paths["vendor/assets"].paths.select { |d| File.directory?(d) }) - app.config.assets.paths.unshift(*paths["lib/assets"].paths.select { |d| File.directory?(d) }) - app.config.assets.paths.unshift(*paths["app/assets"].paths.select { |d| File.directory?(d) }) - end + app.config.assets.paths.unshift(*paths["vendor/assets"].existent_directories) + app.config.assets.paths.unshift(*paths["lib/assets"].existent_directories) + app.config.assets.paths.unshift(*paths["app/assets"].existent_directories) end end end @@ -57,8 +64,11 @@ module Sprockets class Railtie < ::Rails::Railtie - LOOSE_APP_ASSETS = lambda do |filename, path| - path =~ /app\/assets/ && !%w(.js .css).include?(File.extname(filename)) + include Sprockets::Rails::Utils + + LOOSE_APP_ASSETS = lambda do |logical_path, filename| + filename.start_with?(::Rails.root.join("app/assets").to_s) && + !['.js', '.css', ''].include?(File.extname(logical_path)) end class OrderedOptions < ActiveSupport::OrderedOptions @@ -68,92 +78,140 @@ end config.assets = OrderedOptions.new - config.assets._blocks = [] - config.assets.paths = [] - config.assets.prefix = "/assets" - config.assets.manifest = nil - config.assets.precompile = [LOOSE_APP_ASSETS, /(?:\/|\\|\A)application\.(css|js)$/] - config.assets.version = "" - config.assets.debug = false - config.assets.compile = true - config.assets.digest = false + config.assets._blocks = [] + config.assets.paths = [] + config.assets.prefix = "/assets" + config.assets.manifest = nil + if using_sprockets4? + config.assets.precompile = %w( manifest.js ) + else + config.assets.precompile = [LOOSE_APP_ASSETS, /(?:\/|\\|\A)application\.(css|js)$/] + end + config.assets.version = "" + config.assets.debug = false + config.assets.compile = true + config.assets.digest = true + config.assets.cache_limit = 50.megabytes + + config.assets.configure do |env| + config.assets.paths.each { |path| env.append_path(path) } + end + + config.assets.configure do |env| + env.context_class.send :include, ::Sprockets::Rails::Context + env.context_class.assets_prefix = config.assets.prefix + env.context_class.digest_assets = config.assets.digest + env.context_class.config = config.action_controller + end + + config.assets.configure do |env| + env.cache = Sprockets::Cache::FileStore.new( + "#{env.root}/tmp/cache/assets", + config.assets.cache_limit, + env.logger + ) + end + + Sprockets.register_dependency_resolver 'rails-env' do + ::Rails.env.to_s + end + + config.assets.configure do |env| + env.depend_on 'rails-env' + end + + config.assets.configure do |env| + env.version = config.assets.version + end rake_tasks do |app| require 'sprockets/rails/task' Sprockets::Rails::Task.new(app) end - config.after_initialize do |app| - config = app.config - - # Configuration options that should invalidate - # the Sprockets cache when changed. - app.assets.version = [ - app.assets.version, - config.assets.version, - config.action_controller.relative_url_root, - (config.action_controller.asset_host unless config.action_controller.asset_host.respond_to?(:call)), - Sprockets::Rails::VERSION - ].compact.join('-') - - # Copy config.assets.paths to Sprockets - config.assets.paths.each do |path| - app.assets.append_path path + def build_environment(app, initialized = nil) + initialized = app.initialized? if initialized.nil? + unless initialized + ::Rails.logger.warn "Application uninitialized: Try calling YourApp::Application.initialize!" end + env = Sprockets::Environment.new(app.root.to_s) + + config = app.config + # Run app.assets.configure blocks config.assets._blocks.each do |block| - block.call app.assets + block.call(env) end # Set compressors after the configure blocks since they can # define new compressors and we only accept existent compressors. - app.assets.js_compressor = config.assets.js_compressor - app.assets.css_compressor = config.assets.css_compressor + env.js_compressor = config.assets.js_compressor + env.css_compressor = config.assets.css_compressor # No more configuration changes at this point. # With cache classes on, Sprockets won't check the FS when files # change. Preferable in production when the FS only changes on # deploys when the app restarts. if config.cache_classes - app.assets = app.assets.index + env = env.cached end - manifest_assets_path = File.join(config.paths['public'].first, config.assets.prefix) + env + end + + def self.build_manifest(app) + config = app.config + path = File.join(config.paths['public'].first, config.assets.prefix) + Sprockets::Manifest.new(app.assets, path, config.assets.manifest) + end + + config.after_initialize do |app| + config = app.config + if config.assets.compile - app.assets_manifest = Sprockets::Manifest.new(app.assets, manifest_assets_path, config.assets.manifest) - else - app.assets_manifest = Sprockets::Manifest.new(manifest_assets_path, config.assets.manifest) + app.assets = self.build_environment(app, true) + app.routes.prepend do + mount app.assets => config.assets.prefix + end + end + + app.assets_manifest = build_manifest(app) + + if config.assets.resolve_with.nil? + config.assets.resolve_with = [] + config.assets.resolve_with << :manifest if config.assets.digest && !config.assets.debug + config.assets.resolve_with << :environment if config.assets.compile + end + + ActionDispatch::Routing::RouteWrapper.class_eval do + class_attribute :assets_prefix + + if defined?(prepend) && ::Rails.version >= '4' + prepend Sprockets::Rails::RouteWrapper + else + include Sprockets::Rails::RouteWrapper + end + + self.assets_prefix = config.assets.prefix end ActiveSupport.on_load(:action_view) do include Sprockets::Rails::Helper # Copy relevant config to AV context - self.debug_assets = config.assets.debug - self.digest_assets = config.assets.digest - self.assets_prefix = config.assets.prefix - - # Copy over to Sprockets as well - context = app.assets.context_class - context.assets_prefix = config.assets.prefix - context.digest_assets = config.assets.digest - context.config = config.action_controller + self.debug_assets = config.assets.debug + self.digest_assets = config.assets.digest + self.assets_prefix = config.assets.prefix + self.assets_precompile = config.assets.precompile - self.assets_environment = app.assets if config.assets.compile + self.assets_environment = app.assets self.assets_manifest = app.assets_manifest - end - Sprockets::Rails::Helper.precompile ||= app.config.assets.precompile - Sprockets::Rails::Helper.assets ||= app.assets - Sprockets::Rails::Helper.raise_runtime_errors = app.config.assets.raise_runtime_errors + self.resolve_assets_with = config.assets.resolve_with - if config.assets.compile - if app.routes.respond_to?(:prepend) - app.routes.prepend do - mount app.assets => config.assets.prefix - end - end + # Expose the app precompiled asset check to the view + self.precompiled_asset_checker = -> logical_path { app.asset_precompiled? logical_path } end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/metadata new/metadata --- old/metadata 2015-09-08 03:29:27.000000000 +0200 +++ new/metadata 2016-03-02 18:18:46.000000000 +0100 @@ -1,14 +1,14 @@ --- !ruby/object:Gem::Specification name: sprockets-rails version: !ruby/object:Gem::Version - version: 2.3.3 + version: 3.0.4 platform: ruby authors: - Joshua Peek autorequire: bindir: bin cert_chain: [] -date: 2015-09-08 00:00:00.000000000 Z +date: 2016-03-02 00:00:00.000000000 Z dependencies: - !ruby/object:Gem::Dependency name: sprockets @@ -16,62 +16,56 @@ requirements: - - ">=" - !ruby/object:Gem::Version - version: '2.8' - - - "<" - - !ruby/object:Gem::Version - version: '4.0' + version: 3.0.0 type: :runtime prerelease: false version_requirements: !ruby/object:Gem::Requirement requirements: - - ">=" - !ruby/object:Gem::Version - version: '2.8' - - - "<" - - !ruby/object:Gem::Version - version: '4.0' + version: 3.0.0 - !ruby/object:Gem::Dependency name: actionpack requirement: !ruby/object:Gem::Requirement requirements: - - ">=" - !ruby/object:Gem::Version - version: '3.0' + version: '4.0' type: :runtime prerelease: false version_requirements: !ruby/object:Gem::Requirement requirements: - - ">=" - !ruby/object:Gem::Version - version: '3.0' + version: '4.0' - !ruby/object:Gem::Dependency name: activesupport requirement: !ruby/object:Gem::Requirement requirements: - - ">=" - !ruby/object:Gem::Version - version: '3.0' + version: '4.0' type: :runtime prerelease: false version_requirements: !ruby/object:Gem::Requirement requirements: - - ">=" - !ruby/object:Gem::Version - version: '3.0' + version: '4.0' - !ruby/object:Gem::Dependency name: railties requirement: !ruby/object:Gem::Requirement requirements: - - ">=" - !ruby/object:Gem::Version - version: '3.0' + version: '4.0' type: :development prerelease: false version_requirements: !ruby/object:Gem::Requirement requirements: - - ">=" - !ruby/object:Gem::Version - version: '3.0' + version: '4.0' - !ruby/object:Gem::Dependency name: rake requirement: !ruby/object:Gem::Requirement @@ -120,13 +114,14 @@ extensions: [] extra_rdoc_files: [] files: -- LICENSE +- MIT-LICENSE - README.md - lib/sprockets/rails.rb +- lib/sprockets/rails/context.rb - lib/sprockets/rails/helper.rb -- lib/sprockets/rails/legacy_asset_tag_helper.rb -- lib/sprockets/rails/legacy_asset_url_helper.rb +- lib/sprockets/rails/route_wrapper.rb - lib/sprockets/rails/task.rb +- lib/sprockets/rails/utils.rb - lib/sprockets/rails/version.rb - lib/sprockets/railtie.rb homepage: https://github.com/rails/sprockets-rails @@ -141,7 +136,7 @@ requirements: - - ">=" - !ruby/object:Gem::Version - version: '0' + version: 1.9.3 required_rubygems_version: !ruby/object:Gem::Requirement requirements: - - ">=" @@ -149,9 +144,8 @@ version: '0' requirements: [] rubyforge_project: -rubygems_version: 2.4.7 +rubygems_version: 2.5.1 signing_key: specification_version: 4 summary: Sprockets Rails integration test_files: [] -has_rdoc: