sprockets 4.0.0.beta3 → 4.0.0.beta4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 190eb10207d44db44036ce106c1dcc7947ffc52e
-  data.tar.gz: 49cc56e570a817c030e35b7be44d4adee429285b
+  metadata.gz: 52d1dd6743105d82450959d44e27538e02130e7e
+  data.tar.gz: 02f58032703403898778cc33d6a56e0ca8bbee01
 SHA512:
-  metadata.gz: 20c3b7704e5aa45a458001cfa1213aa04226f5616bb339a818b1333abfe33b0d3f58305165d5170888f8d947f936372f83e39639c40afdb68fc61a3cf6f98348
-  data.tar.gz: 127f4dd25e9d3129b0a65859fc65e31442ca22021debee813d15abf48473a8bd606d862d985156358df406803135f5a2cf5ed363c6ce59010f21f5a8ef60cbdd
+  metadata.gz: ac089336d45577a2647ba6b329c5a62862613674be5969f4312e0d7afbb0cf3a9a06cbc7d9db7dd55649fac74c234da54d4482f83d091c4d2357269502006d99
+  data.tar.gz: 990363e0a8e9545ad6243279075cad733d7b403b45737b0c76b35d4647824e693c9f012c88b4220a431970d649dc7ad3582980311dc30c8e2b7b1871c1e5d611

data/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 Get upgrade notes from Sprockets 3.x to 4.x at https://github.com/rails/sprockets/blob/master/UPGRADING.md
 
+## Master
+
+
+## 4.0.0.beta4
+
+- Changing the version now busts the digest of all assets [#404]
+- Exporter interface added [#386]
+- Using ENV vars in templates will recompile templates when the env vars change. [#365]
+- Source maps for imported sass files with sassc is now fixed [#391]
+- Load paths now in error messages [#322]
+- Cache key added to babel processor [#387]
+- `Environment#find_asset!` can now be used to raise an exception when asset could not be found [#379]
+
 ## 4.0.0.beta3
 
 - Source Map fixes [#255] [#367]

data/bin/sprockets

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+$VERBOSE = nil
 
 require 'sprockets'
 require 'optparse'

data/lib/sprockets.rb

@@ -34,8 +34,10 @@ module Sprockets
     registered_transformers: [].freeze,
     root: __dir__.dup.freeze,
     transformers: Hash.new { |h, k| {}.freeze }.freeze,
+    exporters: Hash.new { |h, k| Set.new.freeze }.freeze,
     version: "",
-    gzip_enabled: true
+    gzip_enabled: true,
+    export_concurrent: true
   }.freeze
 
   @context_class = Context
@@ -126,6 +128,7 @@ module Sprockets
   register_bundle_metadata_reducer '*/*', :data, proc { String.new("") }, :concat
   register_bundle_metadata_reducer 'application/javascript', :data, proc { String.new("") }, Utils.method(:concat_javascript_sources)
   register_bundle_metadata_reducer '*/*', :links, :+
+  register_bundle_metadata_reducer '*/*', :sources, proc { [] }, :+
   register_bundle_metadata_reducer '*/*', :map, SourceMapUtils.method(:concat_source_maps)
 
   require 'sprockets/closure_compressor'
@@ -197,6 +200,11 @@ module Sprockets
   register_mime_type 'application/html+ruby', extensions: ['.html.erb', '.erb', '.rhtml'], charset: :html
   register_mime_type 'application/xml+ruby', extensions: ['.xml.erb', '.rxml']
 
+  require 'sprockets/exporters/file_exporter'
+  require 'sprockets/exporters/zlib_exporter'
+  require 'sprockets/exporters/zopfli_exporter'
+  register_exporter '*/*', Exporters::FileExporter
+  register_exporter '*/*', Exporters::ZlibExporter
 
   register_dependency_resolver 'environment-version' do |env|
     env.version
@@ -210,6 +218,10 @@ module Sprockets
   register_dependency_resolver 'processors' do |env, str|
     env.resolve_processors_cache_key_uri(str)
   end
+  register_dependency_resolver 'env' do |env, str|
+    _, var = str.split(':', 2)
+    ENV[var]
+  end
 
   depend_on 'environment-version'
   depend_on 'environment-paths'

data/lib/sprockets/asset.rb

@@ -67,6 +67,13 @@ module Sprockets
       logical_path.sub(/\.(\w+)$/) { |ext| "-#{etag}#{ext}" }
     end
 
+    # Public: Return load path + logical path with digest spliced in.
+    #
+    # Returns String.
+    def full_digest_path
+      File.join(@load_path, digest_path)
+    end
+
     # Public: Returns String MIME type of asset. Returns nil if type is unknown.
     attr_reader :content_type
 

data/lib/sprockets/autoload.rb

@@ -6,10 +6,11 @@ module Sprockets
     autoload :CoffeeScript, 'sprockets/autoload/coffee_script'
     autoload :Eco, 'sprockets/autoload/eco'
     autoload :EJS, 'sprockets/autoload/ejs'
-    autoload :JSMinC, 'sprockets/autoload/jsminc'    
+    autoload :JSMinC, 'sprockets/autoload/jsminc'
     autoload :Sass, 'sprockets/autoload/sass'
     autoload :SassC, 'sprockets/autoload/sassc'
     autoload :Uglifier, 'sprockets/autoload/uglifier'
     autoload :YUI, 'sprockets/autoload/yui'
+    autoload :Zopfli, 'sprockets/autoload/zopfli'
   end
 end

data/lib/sprockets/autoload/zopfli.rb

@@ -0,0 +1,7 @@
+require 'zopfli'
+
+module Sprockets
+  module Autoload
+    Zopfli = ::Zopfli
+  end
+end

data/lib/sprockets/babel_processor.rb

@@ -16,6 +16,12 @@ module Sprockets
       instance.call(input)
     end
 
+    def self.cache_key
+      instance.cache_key
+    end
+
+    attr_reader :cache_key
+
     def initialize(options = {})
       @options = options.merge({
         'blacklist' => (options['blacklist'] || []) + ['useStrict'],

data/lib/sprockets/base.rb

@@ -93,6 +93,16 @@ module Sprockets
       find_asset(*args)
     end
 
+    # Find asset by logical path or expanded path.
+    #
+    # If the asset is not found an error will be raised.
+    def find_asset!(*args)
+      uri, _ = resolve!(*args)
+      if uri
+        load(uri)
+      end
+    end
+
     # Pretty inspect
     def inspect
       "#<#{self.class}:0x#{object_id.to_s(16)} " +

data/lib/sprockets/compressing.rb

@@ -102,12 +102,33 @@ module Sprockets
 
     # Public: Enable or disable the creation of Gzip files.
     #
-    # Defaults to true.
+    # To disable gzip generation set to a falsey value:
     #
     #     environment.gzip = false
     #
+    # To enable set to a truthy value. By default zlib wil
+    # be used to gzip assets. If you have the Zopfli gem
+    # installed you can specify the zopfli algorithm to be used
+    # instead:
+    #
+    #     environment.gzip = :zopfli
+    #
     def gzip=(gzip)
       self.config = config.merge(gzip_enabled: gzip).freeze
+
+      case gzip
+      when false, nil
+        self.unregister_exporter Exporters::ZlibExporter
+        self.unregister_exporter Exporters::ZopfliExporter
+      when :zopfli
+        self.unregister_exporter Exporters::ZlibExporter
+        self.register_exporter '*/*', Exporters::ZopfliExporter
+      else
+        self.unregister_exporter Exporters::ZopfliExporter
+        self.register_exporter '*/*', Exporters::ZlibExporter
+      end
+
+      gzip
     end
   end
 end

data/lib/sprockets/configuration.rb

@@ -4,12 +4,13 @@ require 'sprockets/dependencies'
 require 'sprockets/mime'
 require 'sprockets/paths'
 require 'sprockets/processing'
+require 'sprockets/exporting'
 require 'sprockets/transformers'
 require 'sprockets/utils'
 
 module Sprockets
   module Configuration
-    include Paths, Mime, Transformers, Processing, Compressing, Dependencies, Utils
+    include Paths, Mime, Transformers, Processing, Exporting, Compressing, Dependencies, Utils
 
     def initialize_configuration(parent)
       @config = parent.config

data/lib/sprockets/context.rb

@@ -18,6 +18,24 @@ module Sprockets
   # The `Context` also collects dependencies declared by
   # assets. See `DirectiveProcessor` for an example of this.
   class Context
+    # Internal: Proxy for ENV that keeps track of the environment variables used
+    class ENVProxy < SimpleDelegator
+      def initialize(context)
+        @context = context
+        super(ENV)
+      end
+
+      def [](key)
+        @context.depend_on_env(key)
+        super
+      end
+
+      def fetch(key, *)
+        @context.depend_on_env(key)
+        super
+      end
+    end
+
     attr_reader :environment, :filename
 
     def initialize(input)
@@ -42,6 +60,10 @@ module Sprockets
         dependencies: @dependencies }
     end
 
+    def env_proxy
+      ENVProxy.new(self)
+    end
+
     # Returns the environment path that contains the file.
     #
     # If `app/javascripts` and `app/stylesheets` are in your path, and
@@ -122,6 +144,15 @@ module Sprockets
       load(resolve(path))
     end
 
+    # `depend_on_env` allows you to state a dependency on an environment
+    # variable.
+    #
+    # This is used for caching purposes. Any changes in the value of the
+    # environment variable will invalidate the cache of the source file.
+    def depend_on_env(key)
+      @dependencies << "env:#{key}"
+    end
+
     # `require_asset` declares `path` as a dependency of the file. The
     # dependency will be inserted before the file and will only be
     # included once.

data/lib/sprockets/digest_utils.rb

@@ -45,12 +45,8 @@ module Sprockets
         digest << 'Symbol'.freeze
         digest << val.to_s
       },
-      Fixnum => ->(val, digest) {
-        digest << 'Fixnum'.freeze
-        digest << val.to_s
-      },
-      Bignum => ->(val, digest) {
-        digest << 'Bignum'.freeze
+      Integer => ->(val, digest) {
+        digest << 'Integer'.freeze
         digest << val.to_s
       },
       Array => ->(val, digest) {
@@ -74,6 +70,16 @@ module Sprockets
         digest << val.name
       },
     }
+    if 0.class != Integer # Ruby < 2.4
+      ADD_VALUE_TO_DIGEST[Fixnum] = ->(val, digest) {
+        digest << 'Integer'.freeze
+        digest << val.to_s
+      }
+      ADD_VALUE_TO_DIGEST[Bignum] = ->(val, digest) {
+        digest << 'Integer'.freeze
+        digest << val.to_s
+      }
+    end
     ADD_VALUE_TO_DIGEST.default_proc = ->(_, val) {
       raise TypeError, "couldn't digest #{ val }"
     }

data/lib/sprockets/environment.rb

@@ -31,6 +31,10 @@ module Sprockets
       cached.find_asset(*args)
     end
 
+    def find_asset!(*args)
+      cached.find_asset!(*args)
+    end
+
     def find_all_linked_assets(*args, &block)
       cached.find_all_linked_assets(*args, &block)
     end

data/lib/sprockets/erb_processor.rb

@@ -1,31 +1,32 @@
 # frozen_string_literal: true
 require 'erb'
 
-module Sprockets
-  class ERBProcessor
-    # Public: Return singleton instance with default options.
-    #
-    # Returns ERBProcessor object.
-    def self.instance
-      @instance ||= new
-    end
+class Sprockets::ERBProcessor
+  # Public: Return singleton instance with default options.
+  #
+  # Returns ERBProcessor object.
+  def self.instance
+    @instance ||= new
+  end
+
+  def self.call(input)
+    instance.call(input)
+  end
+
+  def initialize(&block)
+    @block = block
+  end
 
-    def self.call(input)
-      instance.call(input)
-    end
+  def call(input)
+    engine = ::ERB.new(input[:data], nil, '<>')
+    engine.filename = input[:filename]
 
-    def initialize(&block)
-      @block = block
-    end
+    context = input[:environment].context_class.new(input)
+    klass = (class << context; self; end)
+    klass.const_set(:ENV, context.env_proxy)
+    klass.class_eval(&@block) if @block
 
-    def call(input)
-      engine = ::ERB.new(input[:data], nil, '<>')
-      context = input[:environment].context_class.new(input)
-      klass = (class << context; self; end)
-      klass.class_eval(&@block) if @block
-      engine.def_method(klass, :_evaluate_template, input[:filename])
-      data = context._evaluate_template
-      context.metadata.merge(data: data)
-    end
+    data = engine.result(context.instance_eval('binding'))
+    context.metadata.merge(data: data)
   end
 end

data/lib/sprockets/exporters/base.rb

@@ -0,0 +1,72 @@
+module Sprockets
+  module Exporters
+    # Convienence class for all exporters to inherit from
+    #
+    # An exporter is responsible for exporting a Sprockets::Asset
+    # to a file system. For example the Exporters::File class
+    # writes the asset to it's destination. The Exporters::Zlib class
+    # writes a gzip copy of the asset to disk.
+    class Base
+      attr_reader :asset, :environment, :directory, :target
+
+      # Public: Creates new instance
+      #
+      # Initialize will be called with
+      # keyword arguments:
+      #
+      # - asset: An instance of Sprockets::Asset.
+      # - environment: An instance of Sprockets::Environment.
+      # - directory: String representing the target directory to write to.
+      #
+      # These will all be stored as accessible values. In addition a
+      # +target+ will be available which is the target directory and
+      # the asset's digest path combined.
+      def initialize(asset: nil, environment: nil, directory: nil)
+        @asset       = asset
+        @environment = environment
+        @directory   = directory
+        @target      = ::File.join(directory, asset.digest_path)
+        setup
+      end
+
+      # Public: Callback that is executed after intialization
+      #
+      # Any setup that needs to be done can be performed in the +setup+
+      # method. It will be called immediately after initialization.
+      def setup
+      end
+
+      # Public: Handles logic for skipping exporter and notifying logger
+      #
+      # The `skip?` will be called before anything will be written.
+      # If `skip?` returns truthy it will not continue. This method
+      # takes a `logger` that responds to +debug+ and +info+.  The `skip?`
+      # method is the only place expected to write to a logger, any other
+      # messages may produce jumbled logs.
+      def skip?(logger)
+        false
+      end
+
+      # Public: Contains logic for writing "exporting" asset to disk
+      #
+      # If the exporter is not skipped it then Sprockets will execute it's
+      # `call` method. This method takes no arguments and should only use
+      # elements passed in via initialize or stored in `setup`.
+      def call
+        raise "Must subclass and implement call"
+      end
+
+      # Public: Yields a file that can be written to with the input
+      #
+      # `filename`. Defaults to the `target`. Method
+      # is safe to use in forked or threaded environments.
+      def write(filename = target)
+        FileUtils.mkdir_p File.dirname(filename)
+        PathUtils.atomic_write(filename) do |f|
+          yield f
+        end
+      end
+    end
+  end
+end
+

data/lib/sprockets/exporters/file_exporter.rb

@@ -0,0 +1,24 @@
+require 'sprockets/exporters/base'
+
+module Sprockets
+  module Exporters
+    # Writes a an asset file to disk
+    class FileExporter < Exporters::Base
+      def skip?(logger)
+        if ::File.exist?(target)
+          logger.debug "Skipping #{ target }, already exists"
+          true
+        else
+          logger.info "Writing #{ target }"
+          false
+        end
+      end
+
+      def call
+        write(target) do |file|
+          file.write(asset.source)
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/exporters/zlib_exporter.rb

@@ -0,0 +1,33 @@
+require 'sprockets/exporters/base'
+require 'sprockets/utils/gzip'
+
+module Sprockets
+  module Exporters
+    # Generates a `.gz` file using the zlib algorithm built into
+    # Ruby's standard library.
+    class ZlibExporter < Exporters::Base
+      def setup
+        @gzip_target = "#{ target }.gz"
+        @gzip = Sprockets::Utils::Gzip.new(asset, archiver: Utils::Gzip::ZlibArchiver)
+      end
+
+      def skip?(logger)
+        return true if environment.skip_gzip?
+        return true if @gzip.cannot_compress?
+        if ::File.exist?(@gzip_target)
+          logger.debug "Skipping #{ @gzip_target }, already exists"
+          true
+        else
+          logger.info "Writing #{ @gzip_target }"
+          false
+        end
+      end
+
+      def call
+        write(@gzip_target) do |file|
+          @gzip.compress(file, target)
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/exporters/zopfli_exporter.rb

@@ -0,0 +1,14 @@
+require 'sprockets/exporters/zlib_exporter'
+
+module Sprockets
+  module Exporters
+    # Generates a `.gz` file using the zopfli algorithm from the
+    # Zopfli gem.
+    class ZopfliExporter < ZlibExporter
+      def setup
+        @gzip_target = "#{ target }.gz"
+        @gzip = Sprockets::Utils::Gzip.new(asset, archiver: Utils::Gzip::ZopfliArchiver)
+      end
+    end
+  end
+end

data/lib/sprockets/exporting.rb

@@ -0,0 +1,73 @@
+module Sprockets
+  # `Exporting` is an internal mixin whose public methods are exposed on
+  # the `Environment` and `CachedEnvironment` classes.
+  module Exporting
+    # Exporters are ran on the assets:precompile task
+    def exporters
+      config[:exporters]
+    end
+
+    # Public: Registers a new Exporter `klass` for `mime_type`.
+    #
+    # If your exporter depends on one or more other exporters you can
+    # specify this via the `depend_on` keyword.
+    #
+    #     register_exporter '*/*', Sprockets::Exporters::ZlibExporter
+    #
+    # This ensures that `Sprockets::Exporters::File` will always execute before
+    # `Sprockets::Exporters::Zlib`
+    def register_exporter(mime_types, klass = nil)
+      mime_types = Array(mime_types)
+
+      mime_types.each do |mime_type|
+        self.config = hash_reassoc(config, :exporters, mime_type) do |_exporters|
+          _exporters << klass
+        end
+      end
+    end
+
+    # Public: Remove Exporting processor `klass` for `mime_type`.
+    #
+    #     environment.unregister_exporter '*/*', Sprockets::Exporters::Zlib
+    #
+    # Can be called without a mime type
+    #
+    #     environment.unregister_exporter Sprockets::Exporters::Zlib
+    #
+    # Does not remove any exporters that depend on `klass`.
+    def unregister_exporter(mime_types, exporter = nil)
+      unless mime_types.is_a? Array
+        if mime_types.is_a? String
+          mime_types = [mime_types]
+        else # called with no mime type
+          exporter = mime_types
+          mime_types = nil
+        end
+      end
+
+      self.config = hash_reassoc(config, :exporters) do |_exporters|
+        _exporters.each do |mime_type, exporters_array|
+          next if mime_types && !mime_types.include?(mime_type)
+          if exporters_array.include? exporter
+            _exporters[mime_type] = exporters_array.dup.delete exporter
+          end
+        end
+      end
+    end
+
+    # Public: Checks if concurrent exporting is allowed
+    def export_concurrent
+      config[:export_concurrent]
+    end
+
+    # Public: Enable or disable the concurrently exporting files
+    #
+    # Defaults to true.
+    #
+    #     environment.export_concurrent = false
+    #
+    def export_concurrent=(export_concurrent)
+      self.config = config.merge(export_concurrent: export_concurrent).freeze
+    end
+  end
+end

data/lib/sprockets/loader.rb

@@ -163,7 +163,7 @@ module Sprockets
           source = result.delete(:data)
           metadata = result
           metadata[:charset] = source.encoding.name.downcase unless metadata.key?(:charset)
-          metadata[:digest]  = digest(source)
+          metadata[:digest]  = digest(self.version + source)
           metadata[:length]  = source.bytesize
         else
           dependencies << build_file_digest_uri(unloaded.filename)

data/lib/sprockets/manifest.rb

@@ -5,7 +5,6 @@ require 'time'
 require 'concurrent'
 
 require 'sprockets/manifest_utils'
-require 'sprockets/utils/gzip'
 
 module Sprockets
   # The Manifest logs the contents of assets compiled to a single directory. It
@@ -147,7 +146,7 @@ module Sprockets
       end
     end
 
-    # Compile and write asset to directory. The asset is written to a
+    # Compile asset to directory. The asset is written to a
     # fingerprinted filename like
     # `application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js`. An entry is
     # also inserted into the manifest file.
@@ -159,14 +158,15 @@ module Sprockets
         raise Error, "manifest requires environment for compilation"
       end
 
-      filenames              = []
-      concurrent_compressors = []
-      concurrent_writers     = []
+      filenames            = []
+      concurrent_exporters = []
+      executor             = Concurrent::FixedThreadPool.new(Concurrent.processor_count)
 
       find(*args) do |asset|
+        mtime = Time.now.iso8601
         files[asset.digest_path] = {
           'logical_path' => asset.logical_path,
-          'mtime'        => Time.now.iso8601,
+          'mtime'        => mtime,
           'size'         => asset.bytesize,
           'digest'       => asset.hexdigest,
 
@@ -177,34 +177,28 @@ module Sprockets
         }
         assets[asset.logical_path] = asset.digest_path
 
-        target = File.join(dir, asset.digest_path)
-
-        if File.exist?(target)
-          logger.debug "Skipping #{target}, already exists"
-        else
-          logger.info "Writing #{target}"
-          write_file = Concurrent::Future.execute { asset.write_to target }
-          concurrent_writers << write_file
-        end
         filenames << asset.filename
 
-        next if environment.skip_gzip?
-        gzip = Utils::Gzip.new(asset)
-        next if gzip.cannot_compress?(environment.mime_types)
+        promise      = nil
+        exporters_for_asset(asset) do |exporter|
+          next if exporter.skip?(logger)
 
-        if File.exist?("#{target}.gz")
-          logger.debug "Skipping #{target}.gz, already exists"
-        else
-          logger.info "Writing #{target}.gz"
-          concurrent_compressors << Concurrent::Future.execute do
-            write_file.wait! if write_file
-            gzip.compress(target)
+          if !environment.export_concurrent
+            exporter.call
+            next
           end
-        end
 
+          if promise.nil?
+            promise = Concurrent::Promise.new(executor: executor) { exporter.call }
+            concurrent_exporters << promise.execute
+          else
+            concurrent_exporters << promise.then { exporter.call }
+          end
+        end
       end
-      concurrent_writers.each(&:wait!)
-      concurrent_compressors.each(&:wait!)
+
+      # make sure all exporters have finished before returning the main thread
+      concurrent_exporters.each(&:wait!)
       save
 
       filenames
@@ -284,6 +278,35 @@ module Sprockets
     end
 
     private
+
+      # Given an asset, finds all exporters that
+      # match its mime-type.
+      #
+      # Will yield each expoter to the passed in block.
+      #
+      #     array = []
+      #     puts asset.content_type # => "application/javascript"
+      #     exporters_for_asset(asset) do |exporter|
+      #       array << exporter
+      #     end
+      #     # puts array => [Exporters::FileExporter, Exporters::ZlibExporter]
+      def exporters_for_asset(asset)
+        exporters = [Exporters::FileExporter]
+
+        environment.exporters.each do |mime_type, exporter_list|
+          next unless environment.match_mime_type? asset.content_type, mime_type
+          exporter_list.each do |exporter|
+            exporters << exporter
+          end
+        end
+
+        exporters.uniq!
+
+        exporters.each do |exporter|
+          yield exporter.new(asset: asset, environment: environment, directory: dir)
+        end
+      end
+
       def json_decode(obj)
         JSON.parse(obj, create_additions: false)
       end

data/lib/sprockets/path_utils.rb

@@ -6,6 +6,7 @@ module Sprockets
   # when code actually wants to reference ::FileUtils.
   module PathUtils
     extend self
+    require 'pathname'
 
     # Public: Like `File.stat`.
     #
@@ -73,8 +74,6 @@ module Sprockets
     #
     # Returns true if path is absolute, otherwise false.
     if File::ALT_SEPARATOR
-      require 'pathname'
-
       # On Windows, ALT_SEPARATOR is \
       # Delegate to Pathname since the logic gets complex.
       def absolute_path?(path)
@@ -102,6 +101,33 @@ module Sprockets
       path =~ /^\.\.?($|#{SEPARATOR_PATTERN})/ ? true : false
     end
 
+    # Public: Get relative path from `start` to `dest`.
+    #
+    # start - String start path (file or dir)
+    # dest  - String destination path
+    #
+    # Returns relative String path from `start` to `dest`
+    def relative_path_from(start, dest)
+      start, dest = Pathname.new(start), Pathname.new(dest)
+      start = start.dirname unless start.directory?
+      dest.relative_path_from(start).to_s
+    end
+
+    # Public: Joins path to base path.
+    #
+    # base - Root path
+    # path - Extending path
+    #
+    # Example
+    #
+    #     join('base/path/', '../file.js')
+    #     # => 'base/file.js'
+    #
+    # Returns string path starting from base and ending at path
+    def join(base, path)
+      (Pathname.new(base) + path).to_s
+    end
+
     # Internal: Get relative path for root path and subpath.
     #
     # path    - String path

data/lib/sprockets/processing.rb

@@ -218,9 +218,9 @@ module Sprockets
         end
       end
 
-      def unregister_config_processor(type, mime_type, proccessor)
+      def unregister_config_processor(type, mime_type, processor)
         self.config = hash_reassoc(config, type, mime_type) do |processors|
-          processors.delete(proccessor)
+          processors.delete_if { |p| p == processor || p.class == processor }
           processors
         end
       end

data/lib/sprockets/processor_utils.rb

@@ -116,12 +116,10 @@ module Sprockets
     VALID_METADATA_VALUE_TYPES = Set.new([
       String,
       Symbol,
-      Fixnum,
-      Bignum,
       TrueClass,
       FalseClass,
       NilClass
-    ]).freeze
+    ] + (0.class == Integer ? [Integer] : [Bignum, Fixnum])).freeze
 
     # Internal: Set of all nested compound metadata types that can nest values.
     VALID_METADATA_COMPOUND_TYPES = Set.new([

data/lib/sprockets/resolve.rb

@@ -56,6 +56,9 @@ module Sprockets
 
         message << " with type '#{kargs[:accept]}'" if kargs[:accept]
 
+        load_paths = kargs[:load_paths] || config[:paths]
+        message << "\nChecked in these paths: \n  #{ load_paths.join("\n  ") }"
+
         raise FileNotFound, message
       end
 

data/lib/sprockets/sass_processor.rb

@@ -100,11 +100,14 @@ module Sprockets
 
     private
 
+    def expand_source(source, env)
+      uri, _ = env.resolve!(source, pipeline: :source)
+      env.load(uri).digest_path
+    end
+
     def expand_map_sources(mapping, env)
       mapping.each do |map|
-        uri, _ = env.resolve!(map[:source], pipeline: :source)
-        source_path = env.load(uri).digest_path
-        map[:source] = source_path
+        map[:source] = expand_source(map[:source], env)
       end
     end
 

data/lib/sprockets/sassc_processor.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require 'sprockets/sass_processor'
+require 'sprockets/path_utils'
 require 'base64'
 
 module Sprockets
@@ -22,39 +23,42 @@ module Sprockets
       options = engine_options(input, context)
       engine = Autoload::SassC::Engine.new(input[:data], options)
 
-      data = Utils.module_include(Autoload::SassC::Script::Functions, @functions) do
-        engine.render
+      css = Utils.module_include(Autoload::SassC::Script::Functions, @functions) do
+        engine.render.sub(/^\n^\/\*# sourceMappingURL=.*\*\/$/m, '')
       end
 
-      match_data = data.match(/(.*)\n\/\*# sourceMappingURL=data:application\/json;base64,(.+) \*\//m)
-      css, map = match_data[1], Base64.decode64(match_data[2])
+      map = SourceMapUtils.decode_json_source_map(engine.source_map)
+      sources = map['sources'].map do |s|
+        expand_source(PathUtils.join(File.dirname(input[:filename]), s), input[:environment])
+      end
+
+      map = map["mappings"].each do |m|
+        m[:source] = PathUtils.join(File.dirname(input[:filename]), m[:source])
+      end
 
       map = SourceMapUtils.combine_source_maps(
         input[:metadata][:map],
-        change_source(SourceMapUtils.decode_json_source_map(map)["mappings"], input[:source_path])
+        expand_map_sources(map, input[:environment])
       )
 
       engine.dependencies.each do |dependency|
         context.metadata[:dependencies] << URIUtils.build_file_digest_uri(dependency.filename)
       end
 
-      context.metadata.merge(data: css, map: map)
+      context.metadata.merge(data: css, map: map, sources: sources)
     end
 
     private
 
-    def change_source(mappings, source)
-      mappings.each { |m| m[:source] = source }
-    end
-
     def engine_options(input, context)
       merge_options({
         filename: input[:filename],
         syntax: self.class.syntax,
         load_paths: input[:environment].paths,
         importer: @importer_class,
-        source_map_embed: true,
-        source_map_file: '.',
+        source_map_contents: true,
+        source_map_file: "#{input[:filename]}.map",
+        omit_source_map_url: true,
         sprockets: {
           context: context,
           environment: input[:environment],

data/lib/sprockets/source_map_comment_processor.rb

@@ -21,8 +21,10 @@ module Sprockets
       uri, _ = env.resolve!(input[:filename], accept: map_type)
       map = env.load(uri)
 
+      path = PathUtils.relative_path_from(input[:filename], map.full_digest_path)
+
       asset.metadata.merge(
-        data: asset.source + (comment % map.digest_path),
+        data: asset.source + (comment % path),
         links: asset.links + [asset.uri, map.uri]
       )
     end

data/lib/sprockets/source_map_processor.rb

@@ -17,9 +17,10 @@ module Sprockets
 
       env = input[:environment]
 
-      uri, _ = env.resolve!(input[:filename], accept: accept)
-      asset  = env.load(uri)
-      map    = asset.metadata[:map] || []
+      uri, _  = env.resolve!(input[:filename], accept: accept)
+      asset   = env.load(uri)
+      map     = asset.metadata[:map] || []
+      sources = asset.metadata[:sources]
 
       # TODO: Because of the default piplene hack we have to apply dependencies
       #       from compiled asset to the source map, otherwise the source map cache
@@ -39,7 +40,7 @@ module Sprockets
         links << uri
       end
 
-      json = env.encode_json_source_map(map, filename: asset.logical_path)
+      json = env.encode_json_source_map(map, sources: sources, filename: asset.logical_path)
 
       { data: json, links: links, dependencies: dependencies }
     end

data/lib/sprockets/source_map_utils.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require 'json'
+require 'sprockets/path_utils'
 
 module Sprockets
   module SourceMapUtils
@@ -136,7 +137,11 @@ module Sprockets
       case mappings
       when String
       when Array
-        sources ||= mappings.map { |m| m[:source] }.uniq.compact
+        mappings.each do |m|
+          m[:source] = PathUtils.relative_path_from(filename, m[:source])
+        end if filename
+        sources = sources.map { |s| PathUtils.relative_path_from(filename, s) } if filename && sources
+        sources = (Array(sources) + mappings.map { |m| m[:source] }).uniq.compact
         names   ||= mappings.map { |m| m[:name] }.uniq.compact
         mappings = encode_vlq_mappings(mappings, sources: sources, names: names)
       else

data/lib/sprockets/utils/gzip.rb

@@ -2,11 +2,49 @@
 module Sprockets
   module Utils
     class Gzip
+      # Private: Generates a gzipped file based off of reference asset.
+      #
+      #     ZlibArchiver.call(file, source, mtime)
+      #
+      # Compresses a given `source` using stdlib Zlib algorithm
+      # writes contents to the `file` passed in. Sets `mtime` of
+      # written file to passed in `mtime`
+      module ZlibArchiver
+        def self.call(file, source, mtime)
+          gz = Zlib::GzipWriter.new(file, Zlib::BEST_COMPRESSION)
+          gz.mtime = mtime
+          gz.write(source)
+          gz.close
+
+          File.utime(mtime, mtime, file.path)
+        end
+      end
+
+      # Private: Generates a gzipped file based off of reference asset.
+      #
+      #     ZopfliArchiver.call(file, source, mtime)
+      #
+      # Compresses a given `source` using the zopfli gem
+      # writes contents to the `file` passed in. Sets `mtime` of
+      # written file to passed in `mtime`
+      module ZopfliArchiver
+        def self.call(file, source, mtime)
+          compressed_source = Autoload::Zopfli.deflate(source, format: :gzip, mtime: mtime)
+          file.write(compressed_source)
+          file.close
+
+          nil
+        end
+      end
+
+      attr_reader :content_type, :source, :charset, :archiver
+
       # Private: Generates a gzipped file based off of reference file.
-      def initialize(asset)
+      def initialize(asset, archiver: ZlibArchiver)
         @content_type  = asset.content_type
         @source        = asset.source
         @charset       = asset.charset
+        @archiver      = archiver
       end
 
       # What non-text mime types should we compress? This list comes from:
@@ -27,7 +65,7 @@ module Sprockets
       # through a compression algorithm would make them larger.
       #
       # Return Boolean.
-      def can_compress?(mime_types)
+      def can_compress?
         # The "charset" of a mime type is present if the value is
         # encoded text. We can check this value to see if the asset
         # can be compressed.
@@ -39,8 +77,8 @@ module Sprockets
       # Private: Opposite of `can_compress?`.
       #
       # Returns Boolean.
-      def cannot_compress?(mime_types)
-        !can_compress?(mime_types)
+      def cannot_compress?
+        !can_compress?
       end
 
       # Private: Generates a gzipped file based off of reference asset.
@@ -50,16 +88,9 @@ module Sprockets
       # Does not modify the target asset.
       #
       # Returns nothing.
-      def compress(target)
-        mtime = PathUtils.stat(target).mtime
-        PathUtils.atomic_write("#{target}.gz") do |f|
-          gz = Zlib::GzipWriter.new(f, Zlib::BEST_COMPRESSION)
-          gz.mtime = mtime
-          gz.write(@source)
-          gz.close
-
-          File.utime(mtime, mtime, f.path)
-        end
+      def compress(file, target)
+        mtime = Sprockets::PathUtils.stat(target).mtime
+        archiver.call(file, source, mtime)
 
         nil
       end

data/lib/sprockets/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Sprockets
-  VERSION = "4.0.0.beta3"
+  VERSION = "4.0.0.beta4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sprockets
 version: !ruby/object:Gem::Version
-  version: 4.0.0.beta3
+  version: 4.0.0.beta4
 platform: ruby
 authors:
 - Sam Stephenson
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-25 00:00:00.000000000 Z
+date: 2016-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -231,16 +231,22 @@ dependencies:
   name: sassc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.1
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: 1.10.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: uglifier
   requirement: !ruby/object:Gem::Requirement
@@ -269,6 +275,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: zopfli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.4
 description: Sprockets is a Rack-based asset packaging system that concatenates and
   serves JavaScript, CoffeeScript, CSS, Sass, and SCSS.
 email:
@@ -296,6 +316,7 @@ files:
 - lib/sprockets/autoload/sassc.rb
 - lib/sprockets/autoload/uglifier.rb
 - lib/sprockets/autoload/yui.rb
+- lib/sprockets/autoload/zopfli.rb
 - lib/sprockets/babel_processor.rb
 - lib/sprockets/base.rb
 - lib/sprockets/bower.rb
@@ -319,6 +340,11 @@ files:
 - lib/sprockets/environment.rb
 - lib/sprockets/erb_processor.rb
 - lib/sprockets/errors.rb
+- lib/sprockets/exporters/base.rb
+- lib/sprockets/exporters/file_exporter.rb
+- lib/sprockets/exporters/zlib_exporter.rb
+- lib/sprockets/exporters/zopfli_exporter.rb
+- lib/sprockets/exporting.rb
 - lib/sprockets/file_reader.rb
 - lib/sprockets/http_utils.rb
 - lib/sprockets/jsminc_compressor.rb