sprockets 2.2.3 → 4.0.0

data/lib/sprockets/directive_processor.rb

@@ -1,7 +1,6 @@
-require 'pathname'
+# frozen_string_literal: true
+require 'set'
 require 'shellwords'
-require 'tilt'
-require 'yaml'
 
 module Sprockets
   # The `DirectiveProcessor` is responsible for parsing and evaluating
@@ -20,10 +19,9 @@ module Sprockets
   #      *= require "baz"
   #      */
   #
-  # The Processor is implemented as a `Tilt::Template` and is loosely
-  # coupled to Sprockets. This makes it possible to disable or modify
-  # the processor to do whatever you'd like. You could add your own
-  # custom directives or invent your own directive syntax.
+  # This makes it possible to disable or modify the processor to do whatever
+  # you'd like. You could add your own custom directives or invent your own
+  # directive syntax.
   #
   # `Environment#processors` includes `DirectiveProcessor` by default.
   #
@@ -36,25 +34,7 @@ module Sprockets
   #
   #     env.register_processor('text/css', MyProcessor)
   #
-  class DirectiveProcessor < Tilt::Template
-    # Directives will only be picked up if they are in the header
-    # of the source file. C style (/* */), JavaScript (//), and
-    # Ruby (#) comments are supported.
-    #
-    # Directives in comments after the first non-whitespace line
-    # of code will not be processed.
-    #
-    HEADER_PATTERN = /
-      \A (
-        (?m:\s*) (
-          (\/\* (?m:.*?) \*\/) |
-          (\#\#\# (?m:.*?) \#\#\#) |
-          (\/\/ .* \n?)+ |
-          (\# .* \n?)+
-        )
-      )+
-    /x
-
+  class DirectiveProcessor
     # Directives are denoted by a `=` followed by the name, then
     # argument list.
     #
@@ -65,77 +45,121 @@ module Sprockets
     #     //= require "foo"
     #
     DIRECTIVE_PATTERN = /
-      ^ [\W]* = \s* (\w+.*?) (\*\/)? $
+      ^ \W* = \s* (\w+.*?) (\*\/)? $
     /x
 
-    attr_reader :pathname
-    attr_reader :header, :body
+    def self.instance
+      # Default to C comment styles
+      @instance ||= new(comments: ["//", ["/*", "*/"]])
+    end
+
+    def self.call(input)
+      instance.call(input)
+    end
 
-    def prepare
-      @pathname = Pathname.new(file)
+    def initialize(comments: [])
+      @header_pattern = compile_header_pattern(Array(comments))
+    end
 
-      @header = data[HEADER_PATTERN, 0] || ""
-      @body   = $' || data
-      # Ensure body ends in a new line
-      @body  += "\n" if @body != "" && @body !~ /\n\Z/m
+    def call(input)
+      dup._call(input)
+    end
 
-      @included_pathnames = []
-      @compat             = false
+    def _call(input)
+      @environment  = input[:environment]
+      @uri          = input[:uri]
+      @filename     = input[:filename]
+      @dirname      = File.dirname(@filename)
+      # If loading a source map file like `application.js.map` resolve
+      # dependencies using `.js` instead of `.js.map`
+      @content_type = SourceMapProcessor.original_content_type(input[:content_type], error_when_not_found: false)
+      @required     = Set.new(input[:metadata][:required])
+      @stubbed      = Set.new(input[:metadata][:stubbed])
+      @links        = Set.new(input[:metadata][:links])
+      @dependencies = Set.new(input[:metadata][:dependencies])
+      @to_link      = Set.new
+      @to_load      = Set.new
+
+      data, directives = process_source(input[:data])
+      process_directives(directives)
+
+      {
+        data:         data,
+        required:     @required,
+        stubbed:      @stubbed,
+        links:        @links,
+        to_load:      @to_load,
+        to_link:      @to_link,
+        dependencies: @dependencies
+      }
     end
 
-    # Implemented for Tilt#render.
-    #
-    # `context` is a `Context` instance with methods that allow you to
-    # access the environment and append to the bundle. See `Context`
-    # for the complete API.
-    def evaluate(context, locals, &block)
-      @context = context
+    protected
+      # Directives will only be picked up if they are in the header
+      # of the source file. C style (/* */), JavaScript (//), and
+      # Ruby (#) comments are supported.
+      #
+      # Directives in comments after the first non-whitespace line
+      # of code will not be processed.
+      def compile_header_pattern(comments)
+        re = comments.map { |c|
+          case c
+          when String
+            "(?:#{Regexp.escape(c)}.*\\n?)+"
+          when Array
+            "(?:#{Regexp.escape(c[0])}(?m:.*?)#{Regexp.escape(c[1])})"
+          else
+            raise TypeError, "unknown comment type: #{c.class}"
+          end
+        }.join("|")
+        Regexp.compile("\\A(?:(?m:\\s*)(?:#{re}))+")
+      end
 
-      @result = ""
-      @has_written_body = false
+      def process_source(source)
+        header = source[@header_pattern, 0] || ""
+        body   = $' || source
 
-      process_directives
-      process_source
+        header, directives = extract_directives(header)
 
-      @result
-    end
+        data = +""
+        data.force_encoding(body.encoding)
+        data << header unless header.empty?
+        data << body
+        # Ensure body ends in a new line
+        data << "\n" if data.length > 0 && data[-1] != "\n"
 
-    # Returns the header String with any directives stripped.
-    def processed_header
-      lineno = 0
-      @processed_header ||= header.lines.map { |line|
-        lineno += 1
-        # Replace directive line with a clean break
-        directives.assoc(lineno) ? "\n" : line
-      }.join.chomp
-    end
+        return data, directives
+      end
 
-    # Returns the source String with any directives stripped.
-    def processed_source
-      @processed_source ||= processed_header + body
-    end
+      # Returns an Array of directive structures. Each structure
+      # is an Array with the line number as the first element, the
+      # directive name as the second element, followed by any
+      # arguments.
+      #
+      #     [[1, "require", "foo"], [2, "require", "bar"]]
+      #
+      def extract_directives(header)
+        processed_header = +""
+        directives = []
 
-    # Returns an Array of directive structures. Each structure
-    # is an Array with the line number as the first element, the
-    # directive name as the second element, followed by any
-    # arguments.
-    #
-    #     [[1, "require", "foo"], [2, "require", "bar"]]
-    #
-    def directives
-      @directives ||= header.lines.each_with_index.map { |line, index|
-        if directive = line[DIRECTIVE_PATTERN, 1]
-          name, *args = Shellwords.shellwords(directive)
-          if respond_to?("process_#{name}_directive", true)
-            [index + 1, name, *args]
+        header.lines.each_with_index do |line, index|
+          if directive = line[DIRECTIVE_PATTERN, 1]
+            name, *args = Shellwords.shellwords(directive)
+            if respond_to?("process_#{name}_directive", true)
+              directives << [index + 1, name, *args]
+              # Replace directive line with a clean break
+              line = "\n"
+            end
           end
+          processed_header << line
         end
-      }.compact
-    end
 
-    protected
-      attr_reader :included_pathnames
-      attr_reader :context
+        processed_header.chomp!
+        # Ensure header ends in a new line like before it was processed
+        processed_header << "\n" if processed_header.length > 0 && header[-1] == "\n"
+
+        return processed_header, directives
+      end
 
       # Gathers comment directives in the source and processes them.
       # Any directive method matching `process_*_directive` will
@@ -147,8 +171,8 @@ module Sprockets
       # `process_require_glob_directive`.
       #
       #     class DirectiveProcessor < Sprockets::DirectiveProcessor
-      #       def process_require_glob_directive
-      #         Dir["#{pathname.dirname}/#{glob}"].sort.each do |filename|
+      #       def process_require_glob_directive(glob)
+      #         Dir["#{dirname}/#{glob}"].sort.each do |filename|
       #           require(filename)
       #         end
       #       end
@@ -159,35 +183,20 @@ module Sprockets
       #     env.unregister_processor('text/css', Sprockets::DirectiveProcessor)
       #     env.register_processor('text/css', DirectiveProcessor)
       #
-      def process_directives
+      def process_directives(directives)
         directives.each do |line_number, name, *args|
-          context.__LINE__ = line_number
-          send("process_#{name}_directive", *args)
-          context.__LINE__ = nil
-        end
-      end
-
-      def process_source
-        unless @has_written_body || processed_header.empty?
-          @result << processed_header << "\n"
-        end
-
-        included_pathnames.each do |pathname|
-          @result << context.evaluate(pathname)
-        end
-
-        unless @has_written_body
-          @result << body
-        end
-
-        if compat? && constants.any?
-          @result.gsub!(/<%=(.*?)%>/) { constants[$1.strip] }
+          begin
+            send("process_#{name}_directive", *args)
+          rescue Exception => e
+            e.set_backtrace(["#{@filename}:#{line_number}"] + e.backtrace)
+            raise e
+          end
         end
       end
 
       # The `require` directive functions similar to Ruby's own `require`.
       # It provides a way to declare a dependency on a file in your path
-      # and ensures its only loaded once before the source file.
+      # and ensures it's only loaded once before the source file.
       #
       # `require` works with files in the environment path:
       #
@@ -204,22 +213,13 @@ module Sprockets
       #     //= require "./bar"
       #
       def process_require_directive(path)
-        if @compat
-          if path =~ /<([^>]+)>/
-            path = $1
-          else
-            path = "./#{path}" unless relative?(path)
-          end
-        end
-
-        context.require_asset(path)
+        @required << resolve(path, accept: @content_type, pipeline: :self)
       end
 
-      # `require_self` causes the body of the current file to be
-      # inserted before any subsequent `require` or `include`
-      # directives. Useful in CSS files, where it's common for the
-      # index file to contain global styles that need to be defined
-      # before other dependencies are loaded.
+      # `require_self` causes the body of the current file to be inserted
+      # before any subsequent `require` directives. Useful in CSS files, where
+      # it's common for the index file to contain global styles that need to
+      # be defined before other dependencies are loaded.
       #
       #     /*= require "reset"
       #      *= require_self
@@ -227,26 +227,10 @@ module Sprockets
       #      */
       #
       def process_require_self_directive
-        if @has_written_body
+        if @required.include?(@uri)
           raise ArgumentError, "require_self can only be called once per source file"
         end
-
-        context.require_asset(pathname)
-        process_source
-        included_pathnames.clear
-        @has_written_body = true
-      end
-
-      # The `include` directive works similar to `require` but
-      # inserts the contents of the dependency even if it already
-      # has been required.
-      #
-      #     //= include "header"
-      #
-      def process_include_directive(path)
-        pathname = context.resolve(path)
-        context.depend_on_asset(pathname)
-        included_pathnames << pathname
+        @required << @uri
       end
 
       # `require_directory` requires all the files inside a single
@@ -256,27 +240,8 @@ module Sprockets
       #     //= require_directory "./javascripts"
       #
       def process_require_directory_directive(path = ".")
-        if relative?(path)
-          root = pathname.dirname.join(path).expand_path
-
-          unless (stats = stat(root)) && stats.directory?
-            raise ArgumentError, "require_directory argument must be a directory"
-          end
-
-          context.depend_on(root)
-
-          entries(root).each do |pathname|
-            pathname = root.join(pathname)
-            if pathname.to_s == self.file
-              next
-            elsif context.asset_requirable?(pathname)
-              context.require_asset(pathname)
-            end
-          end
-        else
-          # The path must be relative and start with a `./`.
-          raise ArgumentError, "require_directory argument must be a relative path"
-        end
+        path = expand_relative_dirname(:require_directory, path)
+        require_paths(*@environment.stat_directory_with_dependencies(path))
       end
 
       # `require_tree` requires all the nested files in a directory.
@@ -285,28 +250,8 @@ module Sprockets
       #     //= require_tree "./public"
       #
       def process_require_tree_directive(path = ".")
-        if relative?(path)
-          root = pathname.dirname.join(path).expand_path
-
-          unless (stats = stat(root)) && stats.directory?
-            raise ArgumentError, "require_tree argument must be a directory"
-          end
-
-          context.depend_on(root)
-
-          each_entry(root) do |pathname|
-            if pathname.to_s == self.file
-              next
-            elsif stat(pathname).directory?
-              context.depend_on(pathname)
-            elsif context.asset_requirable?(pathname)
-              context.require_asset(pathname)
-            end
-          end
-        else
-          # The path must be relative and start with a `./`.
-          raise ArgumentError, "require_tree argument must be a relative path"
-        end
+        path = expand_relative_dirname(:require_tree, path)
+        require_paths(*@environment.stat_sorted_tree_with_dependencies(path))
       end
 
       # Allows you to state a dependency on a file without
@@ -322,22 +267,22 @@ module Sprockets
       #     //= depend_on "foo.png"
       #
       def process_depend_on_directive(path)
-        context.depend_on(path)
+        resolve(path)
       end
 
       # Allows you to state a dependency on an asset without including
       # it.
       #
       # This is used for caching purposes. Any changes that would
-      # invalid the asset dependency will invalidate the cache our the
-      # source file.
+      # invalidate the asset dependency will invalidate the cache of
+      # the source file.
       #
       # Unlike `depend_on`, the path must be a requirable asset.
       #
       #     //= depend_on_asset "bar.js"
       #
       def process_depend_on_asset_directive(path)
-        context.depend_on_asset(path)
+        to_load(resolve(path))
       end
 
       # Allows dependency to be excluded from the asset bundle.
@@ -349,58 +294,121 @@ module Sprockets
       #     //= stub "jquery"
       #
       def process_stub_directive(path)
-        context.stub_asset(path)
+        @stubbed << resolve(path, accept: @content_type, pipeline: :self)
+      end
+
+      # Declares a linked dependency on the target asset.
+      #
+      # The `path` must be a valid asset and should not already be part of the
+      # bundle. Any linked assets will automatically be compiled along with the
+      # current.
+      #
+      #   /*= link "logo.png" */
+      #
+      def process_link_directive(path)
+        uri = to_load(resolve(path))
+        @to_link << uri
       end
 
-      # Enable Sprockets 1.x compat mode.
+      # `link_directory` links all the files inside a single
+      # directory. It's similar to `path/*` since it does not follow
+      # nested directories.
+      #
+      #     //= link_directory "./fonts"
       #
-      # Makes it possible to use the same JavaScript source
-      # file in both Sprockets 1 and 2.
+      # Use caution when linking against JS or CSS assets. Include an explicit
+      # extension or content type in these cases.
       #
-      #     //= compat
+      #     //= link_directory "./scripts" .js
       #
-      def process_compat_directive
-        @compat = true
+      def process_link_directory_directive(path = ".", accept = nil)
+        path = expand_relative_dirname(:link_directory, path)
+        accept = expand_accept_shorthand(accept)
+        link_paths(*@environment.stat_directory_with_dependencies(path), accept)
       end
 
-      # Checks if Sprockets 1.x compat mode enabled
-      def compat?
-        @compat
+      # `link_tree` links all the nested files in a directory.
+      # Its glob equivalent is `path/**/*`.
+      #
+      #     //= link_tree "./images"
+      #
+      # Use caution when linking against JS or CSS assets. Include an explicit
+      # extension or content type in these cases.
+      #
+      #     //= link_tree "./styles" .css
+      #
+      def process_link_tree_directive(path = ".", accept = nil)
+        path = expand_relative_dirname(:link_tree, path)
+        accept = expand_accept_shorthand(accept)
+        link_paths(*@environment.stat_sorted_tree_with_dependencies(path), accept)
       end
 
-      # Sprockets 1.x allowed for constant interpolation if a
-      # constants.yml was present. This is only available if
-      # compat mode is on.
-      def constants
-        if compat?
-          pathname = Pathname.new(context.root_path).join("constants.yml")
-          stat(pathname) ? YAML.load_file(pathname) : {}
+    private
+      def expand_accept_shorthand(accept)
+        if accept.nil?
+          nil
+        elsif accept.include?("/")
+          accept
+        elsif accept.start_with?(".")
+          @environment.mime_exts[accept]
         else
-          {}
+          @environment.mime_exts[".#{accept}"]
         end
       end
 
-      # `provide` is stubbed out for Sprockets 1.x compat.
-      # Mutating the path when an asset is being built is
-      # not permitted.
-      def process_provide_directive(path)
+      def require_paths(paths, deps)
+        resolve_paths(paths, deps, accept: @content_type, pipeline: :self) do |uri|
+          @required << uri
+        end
       end
 
-    private
-      def relative?(path)
-        path =~ /^\.($|\.?\/)/
+      def link_paths(paths, deps, accept)
+        resolve_paths(paths, deps, accept: accept) do |uri|
+          @to_link << to_load(uri)
+        end
       end
 
-      def stat(path)
-        context.environment.stat(path)
+      def resolve_paths(paths, deps, **kargs)
+        @dependencies.merge(deps)
+        paths.each do |subpath, stat|
+          next if subpath == @filename || stat.directory?
+          uri, deps = @environment.resolve(subpath, **kargs)
+          @dependencies.merge(deps)
+          yield uri if uri
+        end
       end
 
-      def entries(path)
-        context.environment.entries(path)
+      def expand_relative_dirname(directive, path)
+        if @environment.relative_path?(path)
+          path = File.expand_path(path, @dirname)
+          stat = @environment.stat(path)
+
+          if stat && stat.directory?
+            path
+          else
+            raise ArgumentError, "#{directive} argument must be a directory"
+          end
+        else
+          # The path must be relative and start with a `./`.
+          raise ArgumentError, "#{directive} argument must be a relative path"
+        end
+      end
+
+      def to_load(uri)
+        @to_load << uri
+        uri
       end
 
-      def each_entry(root, &block)
-        context.environment.each_entry(root, &block)
+      def resolve(path, **kargs)
+        # Prevent absolute paths in directives
+        if @environment.absolute_path?(path)
+          raise FileOutsidePaths, "can't require absolute file: #{path}"
+        end
+
+        kargs[:base_path] = @dirname
+        uri, deps = @environment.resolve!(path, **kargs)
+        @dependencies.merge(deps)
+        uri
       end
   end
 end

data/lib/sprockets/eco_processor.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+require 'sprockets/autoload'
+
+module Sprockets
+  # Processor engine class for the Eco compiler. Depends on the `eco` gem.
+  #
+  # For more infomation see:
+  #
+  #   https://github.com/sstephenson/ruby-eco
+  #   https://github.com/sstephenson/eco
+  #
+  module EcoProcessor
+    VERSION = '1'
+
+    def self.cache_key
+      @cache_key ||= "#{name}:#{Autoload::Eco::Source::VERSION}:#{VERSION}".freeze
+    end
+
+    # Compile template data with Eco compiler.
+    #
+    # Returns a JS function definition String. The result should be
+    # assigned to a JS variable.
+    #
+    #     # => "function(...) {...}"
+    #
+    def self.call(input)
+      data = input[:data]
+      input[:cache].fetch([cache_key, data]) do
+        Autoload::Eco.compile(data)
+      end
+    end
+  end
+end

data/lib/sprockets/ejs_processor.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require 'sprockets/autoload'
+
+module Sprockets
+  # Processor engine class for the EJS compiler. Depends on the `ejs` gem.
+  #
+  # For more infomation see:
+  #
+  #   https://github.com/sstephenson/ruby-ejs
+  #
+  module EjsProcessor
+    VERSION = '1'
+
+    def self.cache_key
+      @cache_key ||= "#{name}:#{VERSION}".freeze
+    end
+
+    # Compile template data with EJS compiler.
+    #
+    # Returns a JS function definition String. The result should be
+    # assigned to a JS variable.
+    #
+    #     # => "function(obj){...}"
+    #
+    def self.call(input)
+      data = input[:data]
+      input[:cache].fetch([cache_key, data]) do
+        Autoload::EJS.compile(data)
+      end
+    end
+  end
+end