sprockets-rails 2.3.3 → 3.4.2

data/lib/sprockets/rails/utils.rb

@@ -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

data/lib/sprockets/rails/version.rb

@@ -1,5 +1,5 @@
 module Sprockets
   module Rails
-    VERSION = "2.3.3"
+    VERSION = "3.4.2"
   end
 end

data/lib/sprockets/railtie.rb

@@ -2,9 +2,17 @@ require 'rails'
 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/asset_url_processor'
+require 'sprockets/rails/sourcemapping_url_processor'
+require 'sprockets/rails/context'
 require 'sprockets/rails/helper'
+require 'sprockets/rails/quiet_assets'
+require 'sprockets/rails/route_wrapper'
 require 'sprockets/rails/version'
+require 'set'
 
 module Rails
   class Application
@@ -19,37 +27,40 @@ module Rails
     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 +68,26 @@ end
 
 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
+
+    class ManifestNeededError < StandardError
+      def initialize
+        msg = "Expected to find a manifest file in `app/assets/config/manifest.js`\n" +
+        "But did not, please create this file and use it to link any assets that need\n" +
+        "to be rendered by your app:\n\n" +
+        "Example:\n" +
+        "  //= link_tree ../images\n"  +
+        "  //= link_directory ../javascripts .js\n" +
+        "  //= link_directory ../stylesheets .css\n"  +
+        "and restart your server\n\n" +
+        "For more information see: https://github.com/rails/sprockets/blob/070fc01947c111d35bb4c836e9bb71962a8e0595/UPGRADING.md#manifestjs"
+        super msg
+      end
+    end
+
+    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 +97,173 @@ module Sprockets
     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.precompile                 = []
+    config.assets.prefix                     = "/assets"
+    config.assets.manifest                   = nil
+    config.assets.quiet                      = false
+    config.assets.resolve_assets_in_css_urls = true
+
+    initializer :set_default_precompile do |app|
+      if using_sprockets4?
+        raise ManifestNeededError unless ::Rails.root.join("app/assets/config/manifest.js").exist?
+        app.config.assets.precompile += %w( manifest.js )
+      else
+        app.config.assets.precompile += [LOOSE_APP_ASSETS, /(?:\/|\\|\A)application\.(css|js)$/]
+      end
+    end
+
+    initializer :quiet_assets do |app|
+      if app.config.assets.quiet
+        app.middleware.insert_before ::Rails::Rack::Logger, ::Sprockets::Rails::QuietAssets
+      end
+    end
+
+    initializer :asset_url_processor do |app|
+      if app.config.assets.resolve_assets_in_css_urls
+        Sprockets.register_postprocessor "text/css", ::Sprockets::Rails::AssetUrlProcessor
+      end
+    end
+
+    initializer :asset_sourcemap_url_processor do |app|
+      Sprockets.register_postprocessor "application/javascript", ::Sprockets::Rails::SourcemappingUrlProcessor
+    end
+
+    config.assets.version     = ""
+    config.assets.debug       = false
+    config.assets.compile     = true
+    config.assets.digest      = true
+    config.assets.cache_limit = 50.megabytes
+    config.assets.gzip        = true
+    config.assets.check_precompiled_asset = true
+    config.assets.unknown_asset_fallback  = true
+
+    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
+
+    config.assets.configure do |env|
+      env.gzip = config.assets.gzip if env.respond_to?(:gzip=)
+    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
+        self.debug_assets      = config.assets.debug
+        self.digest_assets     = config.assets.digest
+        self.assets_prefix     = config.assets.prefix
+        self.assets_precompile = config.assets.precompile
 
-        # 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.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
+        self.check_precompiled_asset = config.assets.check_precompiled_asset
+        self.unknown_asset_fallback  = config.assets.unknown_asset_fallback
+        # Expose the app precompiled asset check to the view
+        self.precompiled_asset_checker = -> logical_path { app.asset_precompiled? logical_path }
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sprockets-rails
 version: !ruby/object:Gem::Version
-  version: 2.3.3
+  version: 3.4.2
 platform: ruby
 authors:
 - Joshua Peek
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-09-08 00:00:00.000000000 Z
+date: 2021-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sprockets
@@ -16,62 +16,56 @@ dependencies:
     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: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '5.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -114,26 +108,30 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email: josh@joshpeek.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- LICENSE
+- MIT-LICENSE
 - README.md
 - lib/sprockets/rails.rb
+- lib/sprockets/rails/asset_url_processor.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/quiet_assets.rb
+- lib/sprockets/rails/route_wrapper.rb
+- lib/sprockets/rails/sourcemapping_url_processor.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
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -141,17 +139,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.7
-signing_key: 
+rubygems_version: 3.2.32
+signing_key:
 specification_version: 4
 summary: Sprockets Rails integration
 test_files: []
-has_rdoc: 

data/lib/sprockets/rails/legacy_asset_tag_helper.rb

@@ -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

data/lib/sprockets/rails/legacy_asset_url_helper.rb

@@ -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