sprockets 3.7.5 → 4.0.0.beta1

data/lib/sprockets/transformers.rb

@@ -18,6 +18,8 @@ module Sprockets
       config[:transformers]
     end
 
+    Transformer = Struct.new :from, :to, :proc
+
     # Public: Register a transformer from and to a mime type.
     #
     # from - String mime type
@@ -33,10 +35,30 @@ module Sprockets
     #
     # Returns nothing.
     def register_transformer(from, to, proc)
-      self.config = hash_reassoc(config, :registered_transformers, from) do |transformers|
-        transformers.merge(to => proc)
+      self.config = hash_reassoc(config, :registered_transformers) do |transformers|
+        transformers << Transformer.new(from, to, proc)
+      end
+      compute_transformers!(self.config[:registered_transformers])
+    end
+
+    # Internal: Register transformer for existing type adding a suffix.
+    #
+    # types       - Array of existing mime type Strings
+    # type_format - String suffix formatting string
+    # extname     - String extension to append
+    # processor   - Callable block that accepts an input Hash.
+    #
+    # Returns nothing.
+    def register_transformer_suffix(types, type_format, extname, processor)
+      Array(types).each do |type|
+        extensions, charset = mime_types[type].values_at(:extensions, :charset)
+        parts = type.split('/')
+        suffix_type = type_format.sub('\1', parts[0]).sub('\2', parts[1])
+        extensions = extensions.map { |ext| "#{ext}#{extname}" }
+
+        register_mime_type(suffix_type, extensions: extensions, charset: charset)
+        register_transformer(suffix_type, type, processor)
       end
-      compute_transformers!
     end
 
     # Internal: Resolve target mime type that the source type should be
@@ -89,53 +111,58 @@ module Sprockets
     # types - Array of mime type steps
     #
     # Returns Processor.
-    def compose_transformers(transformers, types)
+    def compose_transformers(transformers, types, preprocessors, postprocessors)
       if types.length < 2
         raise ArgumentError, "too few transform types: #{types.inspect}"
       end
 
-      i = 0
-      processors = []
-
-      loop do
-        src = types[i]
-        dst = types[i+1]
-        break unless src && dst
-
+      processors = types.each_cons(2).map { |src, dst|
         unless processor = transformers[src][dst]
           raise ArgumentError, "missing transformer for type: #{src} to #{dst}"
         end
-        processors.concat config[:postprocessors][src]
-        processors << processor
-        processors.concat config[:preprocessors][dst]
+        processor
+      }
 
-        i += 1
-      end
-
-      if processors.size > 1
-        compose_processors(*processors.reverse)
-      elsif processors.size == 1
-        processors.first
-      end
+      compose_transformer_list processors, preprocessors, postprocessors
     end
 
     private
-      def compute_transformers!
-        registered_transformers = self.config[:registered_transformers]
-        transformers = Hash.new { {} }
+      def compose_transformer_list(transformers, preprocessors, postprocessors)
+        processors = []
+
+        transformers.each do |processor|
+          processors.concat postprocessors[processor.from]
+          processors << processor.proc
+          processors.concat preprocessors[processor.to]
+        end
+
+        if processors.size > 1
+          compose_processors(*processors.reverse)
+        elsif processors.size == 1
+          processors.first
+        end
+      end
+
+      def compute_transformers!(registered_transformers)
+        preprocessors         = self.config[:preprocessors]
+        postprocessors        = self.config[:postprocessors]
+        transformers          = Hash.new { {} }
         inverted_transformers = Hash.new { Set.new }
+        incoming_edges        = registered_transformers.group_by(&:from)
+
+        registered_transformers.each do |t|
+          traversals = dfs_paths([t]) { |k| incoming_edges.fetch(k.to, []) }
 
-        registered_transformers.keys.flat_map do |key|
-          dfs_paths([key]) { |k| registered_transformers[k].keys }
-        end.each do |types|
-          src, dst = types.first, types.last
-          processor = compose_transformers(registered_transformers, types)
+          traversals.each do |nodes|
+            src, dst = nodes.first.from, nodes.last.to
+            processor = compose_transformer_list nodes, preprocessors, postprocessors
 
-          transformers[src] = {} unless transformers.key?(src)
-          transformers[src][dst] = processor
+            transformers[src] = {} unless transformers.key?(src)
+            transformers[src][dst] = processor
 
-          inverted_transformers[dst] = Set.new unless inverted_transformers.key?(dst)
-          inverted_transformers[dst] << src
+            inverted_transformers[dst] = Set.new unless inverted_transformers.key?(dst)
+            inverted_transformers[dst] << src
+          end
         end
 
         self.config = hash_reassoc(config, :transformers) { transformers }

data/lib/sprockets/uglifier_compressor.rb

@@ -1,5 +1,6 @@
 require 'sprockets/autoload'
 require 'sprockets/digest_utils'
+require 'sprockets/source_map_utils'
 
 module Sprockets
   # Public: Uglifier/Uglify compressor.
@@ -15,7 +16,7 @@ module Sprockets
   #       Sprockets::UglifierCompressor.new(comments: :copyright)
   #
   class UglifierCompressor
-    VERSION = '1'
+    VERSION = '2'
 
     # Public: Return singleton instance with default options.
     #
@@ -41,16 +42,22 @@ module Sprockets
         options[:copyright] ||= false
       else
         # Uglifier >= 2.x
-        options[:comments] ||= :none
+        options[:copyright] ||= :none
       end
 
-      @options = options
+      @uglifier = Autoload::Uglifier.new(options)
       @cache_key = "#{self.class.name}:#{Autoload::Uglifier::VERSION}:#{VERSION}:#{DigestUtils.digest(options)}".freeze
     end
 
     def call(input)
-      @uglifier ||= Autoload::Uglifier.new(@options)
-      @uglifier.compile(input[:data])
+      js, map = @uglifier.compile_with_map(input[:data])
+
+      map = SourceMapUtils.combine_source_maps(
+        input[:metadata][:map],
+        SourceMapUtils.decode_json_source_map(map)["mappings"]
+      )
+
+      { data: js, map: map }
     end
   end
 end

data/lib/sprockets/unloaded_asset.rb

@@ -12,8 +12,8 @@ module Sprockets
     #       and full path such as
     #       "file:///Path/app/assets/js/app.js?type=application/javascript"
     # env - The current "environment" that assets are being loaded into.
-    #       We need it so we know where the +root+ (directory where sprockets
-    #       is being invoked). We also need for the `file_digest` method,
+    #       We need it so we know where the +root+ (directory where Sprockets
+    #       is being invoked). We also need it for the `file_digest` method,
     #       since, for some strange reason, memoization is provided by
     #       overriding methods such as `stat` in the `PathUtils` module.
     #
@@ -30,7 +30,7 @@ module Sprockets
     # Internal: Full file path without schema
     #
     # This returns a string containing the full path to the asset without the schema.
-    # Information is loaded lazilly since we want `UnloadedAsset.new(dep, self).relative_path`
+    # Information is loaded lazily since we want `UnloadedAsset.new(dep, self).relative_path`
     # to be fast. Calling this method the first time allocates an array and a hash.
     #
     # Example
@@ -48,8 +48,8 @@ module Sprockets
 
     # Internal: Hash of param values
     #
-    # This information is generated and used internally by sprockets.
-    # Known keys include `:type` which store the asset's mime-type, `:id` which is a fully resolved
+    # This information is generated and used internally by Sprockets.
+    # Known keys include `:type` which stores the asset's mime-type, `:id` which is a fully resolved
     # digest for the asset (includes dependency digest as opposed to a digest of only file contents)
     # and `:pipeline`. Hash may be empty.
     #
@@ -79,12 +79,12 @@ module Sprockets
 
     # Public: Dependency History key
     #
-    # Used to retrieve an array of "histories" each of which contain a set of stored dependencies
+    # Used to retrieve an array of "histories" each of which contains a set of stored dependencies
     # for a given asset path and filename digest.
     #
-    # A dependency can refer to either an asset i.e. index.js
+    # A dependency can refer to either an asset e.g. index.js
     # may rely on jquery.js (so jquery.js is a dependency), or other factors that may affect
-    # compilation, such as the VERSION of sprockets (i.e. the environment) and what "processors"
+    # compilation, such as the VERSION of Sprockets (i.e. the environment) and what "processors"
     # are used.
     #
     # For example a history array with one Set of dependencies may look like:
@@ -97,7 +97,7 @@ module Sprockets
     # This method of asset lookup is used to ensure that none of the dependencies have been modified
     # since last lookup. If one of them has, the key will be different and a new entry must be stored.
     #
-    # URI depndencies are later converted to "compressed" paths
+    # URI dependencies are later converted to "compressed" paths
     #
     # Returns a String.
     def dependency_history_key
@@ -108,8 +108,9 @@ module Sprockets
     #
     # Used to retrieve a string containing the "compressed" path to an asset based on
     # a digest. The digest is generated from dependencies stored via information stored in
-    # the `dependency_history_key` after each of the "dependencies" is "resolved" for example
-    # "environment-version" may be resolved to "environment-1.0-3.2.0" for version "3.2.0" of sprockets
+    # the `dependency_history_key` after each of the "dependencies" is "resolved".
+    # For example "environment-version" may be resolved to "environment-1.0-3.2.0"
+    # for version "3.2.0" of Sprockets
     #
     # Returns a String.
     def digest_key(digest)

data/lib/sprockets/uri_tar.rb

@@ -14,8 +14,10 @@ module Sprockets
       @env  = env
       uri   = uri.to_s
       if uri.include?("://".freeze)
-        @scheme, _, @path = uri.partition("://".freeze)
-        @scheme << "://".freeze
+        uri_array = uri.split("://".freeze)
+        @scheme   = uri_array.shift
+        @scheme   << "://".freeze
+        @path     = uri_array.join("".freeze)
       else
         @scheme = "".freeze
         @path   = uri

data/lib/sprockets/uri_utils.rb

@@ -20,8 +20,6 @@ module Sprockets
   module URIUtils
     extend self
 
-    URI_PARSER = defined?(URI::RFC2396_PARSER) ? URI::RFC2396_PARSER : URI::RFC2396_Parser.new
-
     # Internal: Parse URI into component parts.
     #
     # uri - String uri
@@ -46,15 +44,12 @@ module Sprockets
     def split_file_uri(uri)
       scheme, _, host, _, _, path, _, query, _ = URI.split(uri)
 
-      path = URI_PARSER.unescape(path)
+      path = URI::Generic::DEFAULT_PARSER.unescape(path)
       path.force_encoding(Encoding::UTF_8)
 
       # Hack for parsing Windows "file:///C:/Users/IEUser" paths
       path.gsub!(/^\/([a-zA-Z]:)/, '\1'.freeze)
 
-      host = nil if host && host.empty?
-      query = nil if query && query.empty?
-
       [scheme, host, path, query]
     end
 
@@ -64,8 +59,8 @@ module Sprockets
     def join_file_uri(scheme, host, path, query)
       str = "#{scheme}://"
       str << host if host
-      path = "/#{path}" unless path.start_with?("/")
-      str << URI_PARSER.escape(path)
+      path = "/#{path}" unless path.start_with?("/".freeze)
+      str << URI::Generic::DEFAULT_PARSER.escape(path)
       str << "?#{query}" if query
       str
     end
@@ -77,7 +72,7 @@ module Sprockets
     # Returns true or false.
     def valid_asset_uri?(str)
       # Quick prefix check before attempting a full parse
-      str.start_with?("file://") && parse_asset_uri(str) ? true : false
+      str.start_with?("file://".freeze) && parse_asset_uri(str) ? true : false
     rescue URI::InvalidURIError
       false
     end
@@ -164,7 +159,7 @@ module Sprockets
         when Integer
           query << "#{key}=#{value}"
         when String, Symbol
-          query << "#{key}=#{URI_PARSER.escape(value.to_s)}"
+          query << "#{key}=#{URI::Generic::DEFAULT_PARSER.escape(value.to_s)}"
         when TrueClass
           query << "#{key}"
         when FalseClass, NilClass
@@ -173,7 +168,7 @@ module Sprockets
         end
       end
 
-      "#{query.join('&')}" if query.any?
+      "#{query.join('&'.freeze)}" if query.any?
     end
 
     # Internal: Parse query string into hash of params
@@ -182,9 +177,9 @@ module Sprockets
     #
     # Return Hash of params.
     def parse_uri_query_params(query)
-      query.to_s.split('&').reduce({}) do |h, p|
-        k, v = p.split('=', 2)
-        v = URI_PARSER.unescape(v) if v
+      query.to_s.split('&'.freeze).reduce({}) do |h, p|
+        k, v = p.split('='.freeze, 2)
+        v = URI::Generic::DEFAULT_PARSER.unescape(v) if v
         h[k.to_sym] = v || true
         h
       end

data/lib/sprockets/utils.rb

@@ -14,15 +14,11 @@ module Sprockets
     #
     # Returns false if .dup would raise a TypeError, otherwise true.
     def duplicable?(obj)
-      if RUBY_VERSION >= "2.4.0"
-        true
+      case obj
+      when NilClass, FalseClass, TrueClass, Symbol, Numeric
+        false
       else
-        case obj
-        when NilClass, FalseClass, TrueClass, Symbol, Numeric
-          false
-        else
-          true
-        end
+        true
       end
     end
 
@@ -49,7 +45,8 @@ module Sprockets
     # Similar to Hash#store for nested frozen hashes.
     #
     # hash  - Hash
-    # key   - Object keys. Use multiple keys for nested hashes.
+    # key_a - Object key. Use multiple keys for nested hashes.
+    # key_b - Object key. Use multiple keys for nested hashes.
     # block - Receives current value at key.
     #
     # Examples
@@ -60,13 +57,13 @@ module Sprockets
     #     end
     #
     # Returns duplicated frozen Hash.
-    def hash_reassoc(hash, *keys, &block)
-      if keys.size == 1
-        hash_reassoc1(hash, keys[0], &block)
-      else
-        hash_reassoc1(hash, keys[0]) do |value|
-          hash_reassoc(value, *keys[1..-1], &block)
+    def hash_reassoc(hash, key_a, key_b = nil, &block)
+      if key_b
+        hash_reassoc1(hash, key_a) do |value|
+          hash_reassoc(value, key_b, &block)
         end
+      else
+        hash_reassoc1(hash, key_a, &block)
       end
     end
 
@@ -78,19 +75,16 @@ module Sprockets
     def string_end_with_semicolon?(str)
       i = str.size - 1
       while i >= 0
-        c = str[i].ord
+        c = str[i]
         i -= 1
-
-        # Need to compare against the ordinals because the string can be UTF_8 or UTF_32LE encoded
-        # 0x0A == "\n"
-        # 0x20 == " "
-        # 0x09 == "\t"
-        # 0x3B == ";"
-        unless c == 0x0A || c == 0x20 || c == 0x09
-          return c === 0x3B
+        if c == "\n" || c == " " || c == "\t"
+          next
+        elsif c != ";"
+          return false
+        else
+          return true
         end
       end
-
       true
     end
 
@@ -102,50 +96,11 @@ module Sprockets
     #
     # Returns buf String.
     def concat_javascript_sources(buf, source)
-      buf = +buf
-      if source.bytesize > 0
-        buf << source
-
-        # If the source contains non-ASCII characters, indexing on it becomes O(N).
-        # This will lead to O(N^2) performance in string_end_with_semicolon?, so we should use 32 bit encoding to make sure indexing stays O(1)
-        source = source.encode(Encoding::UTF_32LE) unless source.ascii_only?
-
-        if !string_end_with_semicolon?(source)
-          buf << ";\n"
-        elsif source[source.size - 1].ord != 0x0A
-          buf << "\n"
-        end
+      if buf.bytesize > 0
+        buf << ";" unless string_end_with_semicolon?(buf)
+        buf << "\n" unless buf.end_with?("\n")
       end
-
-      buf
-    end
-
-    # Internal: Prepends a leading "." to an extension if its missing.
-    #
-    #     normalize_extension("js")
-    #     # => ".js"
-    #
-    #     normalize_extension(".css")
-    #     # => ".css"
-    #
-    def normalize_extension(extension)
-      extension = extension.to_s
-      if extension[/^\./]
-        extension
-      else
-        ".#{extension}"
-      end
-    end
-
-    # Internal: Feature detect if UnboundMethods can #bind to any Object or
-    # just Objects that share the same super class.
-    # Basically if RUBY_VERSION >= 2.
-    UNBOUND_METHODS_BIND_TO_ANY_OBJECT = begin
-      foo = Module.new { def bar; end }
-      foo.instance_method(:bar).bind(Object.new)
-      true
-    rescue TypeError
-      false
+      buf << source
     end
 
     # Internal: Inject into target module for the duration of the block.
@@ -160,10 +115,6 @@ module Sprockets
         old_methods[sym] = base.instance_method(sym) if base.method_defined?(sym)
       end
 
-      unless UNBOUND_METHODS_BIND_TO_ANY_OBJECT
-        base.send(:include, mod) unless base < mod
-      end
-
       mod.instance_methods.each do |sym|
         method = mod.instance_method(sym)
         base.send(:define_method, sym, method)
@@ -217,16 +168,16 @@ module Sprockets
     # Returns an Array of node Arrays.
     def dfs_paths(path)
       paths = []
-      stack, seen = [path], Set.new
+      stack = [path]
+      seen  = Set.new
 
       while path = stack.pop
-        if !seen.include?(path.last)
-          seen.add(path.last)
-          paths << path if path.size > 1
+        seen.add(path.last)
+        paths << path
 
-          Array(yield path.last).reverse_each do |node|
-            stack.push(path + [node])
-          end
+        children = yield path.last
+        children.reverse_each do |node|
+          stack.push(path + [node]) unless seen.include?(node)
         end
       end
 

data/lib/sprockets/version.rb

@@ -1,3 +1,3 @@
 module Sprockets
-  VERSION = "3.7.5"
+  VERSION = "4.0.0.beta1"
 end